prjct-cli 1.22.0 → 1.24.0

package/core/sync/oauth-handler.ts

@@ -1,143 +0,0 @@
-/**
- * OAuth Handler - Manages authentication flow for CLI
- *
- * Two modes:
- * 1. Simple: User copies API key from web dashboard
- * 2. Browser (future): Full OAuth device flow
- */
-
-import type { AuthResult } from '../types'
-import { authConfig } from './auth-config'
-import { syncClient } from './sync-client'
-
-class OAuthHandler {
-  /**
-   * Start authentication flow
-   * Opens browser to dashboard where user can create/copy API key
-   */
-  async startAuthFlow(): Promise<{ url: string }> {
-    const apiUrl = await authConfig.getApiUrl()
-    // Dashboard URL where user can get their API key
-    const dashboardUrl = apiUrl.replace('api.', 'app.')
-    const authUrl = `${dashboardUrl}/settings/api-keys`
-
-    return { url: authUrl }
-  }
-
-  /**
-   * Save API key after user provides it
-   */
-  async saveApiKey(apiKey: string): Promise<AuthResult> {
-    // Validate format
-    if (!apiKey.startsWith('prjct_')) {
-      return {
-        success: false,
-        error: 'Invalid API key format. Keys start with "prjct_"',
-      }
-    }
-
-    // Save temporarily to test connection
-    await authConfig.write({ apiKey })
-
-    // Test the key by making a request
-    const isValid = await syncClient.testConnection()
-
-    if (!isValid) {
-      // Clear the invalid key
-      await authConfig.clearAuth()
-      return {
-        success: false,
-        error: 'API key is invalid or expired',
-      }
-    }
-
-    // Key is valid - fetch user info
-    try {
-      const userInfo = await this.fetchUserInfo(apiKey)
-
-      await authConfig.saveAuth(apiKey, userInfo.id, userInfo.email)
-
-      return {
-        success: true,
-        email: userInfo.email,
-      }
-    } catch (_error) {
-      // Key works but couldn't fetch user info - still save it
-      await authConfig.write({ apiKey })
-      return {
-        success: true,
-      }
-    }
-  }
-
-  /**
-   * Fetch user info using the API key
-   */
-  private async fetchUserInfo(
-    apiKey: string
-  ): Promise<{ id: string; email: string; name: string }> {
-    const apiUrl = await authConfig.getApiUrl()
-
-    const response = await fetch(`${apiUrl}/auth/me`, {
-      headers: {
-        'X-Api-Key': apiKey,
-      },
-    })
-
-    if (!response.ok) {
-      throw new Error('Failed to fetch user info')
-    }
-
-    const data = (await response.json()) as {
-      user: { id: string; email: string; name: string }
-    }
-    return data.user
-  }
-
-  /**
-   * Check if currently authenticated
-   */
-  async isAuthenticated(): Promise<boolean> {
-    return await authConfig.hasAuth()
-  }
-
-  /**
-   * Get current auth status
-   */
-  async getStatus(): Promise<{
-    authenticated: boolean
-    email: string | null
-    apiKeyPrefix: string | null
-  }> {
-    return await authConfig.getStatus()
-  }
-
-  /**
-   * Logout - clear all auth data
-   */
-  async logout(): Promise<void> {
-    await authConfig.clearAuth()
-  }
-
-  /**
-   * Open URL in default browser
-   */
-  async openBrowser(url: string): Promise<void> {
-    const { exec } = await import('node:child_process')
-    const { promisify } = await import('node:util')
-    const execAsync = promisify(exec)
-
-    const platform = process.platform
-    const command =
-      platform === 'darwin'
-        ? `open "${url}"`
-        : platform === 'win32'
-          ? `start "${url}"`
-          : `xdg-open "${url}"`
-
-    await execAsync(command)
-  }
-}
-
-export const oauthHandler = new OAuthHandler()
-export default oauthHandler

package/core/sync/sync-client.ts

@@ -1,251 +0,0 @@
-/**
- * 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).
- *
- * PRJ-111: Includes configurable timeout support via AbortController.
- */
-
-import { getTimeout } from '../constants'
-import type { SyncEvent } from '../events'
-import type { SyncBatchResult, SyncClientError, SyncPullResult, SyncStatus } from '../types'
-import authConfig from './auth-config'
-
-// ============================================
-// 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> {
-    // PRJ-111: Add timeout to connection test
-    const controller = new AbortController()
-    const timeoutId = setTimeout(() => controller.abort(), getTimeout('API_REQUEST'))
-
-    try {
-      const { apiUrl, apiKey } = await this.getAuthHeaders()
-
-      if (!apiKey) {
-        clearTimeout(timeoutId)
-        return false
-      }
-
-      const response = await fetch(`${apiUrl}/health`, {
-        method: 'GET',
-        headers: {
-          'X-Api-Key': apiKey,
-        },
-        signal: controller.signal,
-      })
-
-      clearTimeout(timeoutId)
-      return response.ok
-    } catch (_error) {
-      // Network error, timeout, or other issue - expected
-      clearTimeout(timeoutId)
-      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> {
-    // PRJ-111: Add AbortController-based timeout (default: 30s, configurable via PRJCT_TIMEOUT_API_REQUEST)
-    const controller = new AbortController()
-    const timeoutId = setTimeout(() => controller.abort(), getTimeout('API_REQUEST'))
-
-    try {
-      const response = await fetch(url, {
-        ...options,
-        signal: controller.signal,
-      })
-
-      clearTimeout(timeoutId)
-
-      // 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 * 2 ** retryCount,
-          this.retryConfig.maxDelayMs
-        )
-        await this.sleep(delay)
-        return this.fetchWithRetry(url, options, retryCount + 1)
-      }
-
-      return response
-    } catch (error) {
-      clearTimeout(timeoutId)
-
-      // Check if this is a timeout (AbortError)
-      if (error instanceof Error && error.name === 'AbortError') {
-        throw this.createError(
-          'NETWORK_ERROR',
-          `Request timed out. Try increasing PRJCT_TIMEOUT_API_REQUEST (current: ${getTimeout('API_REQUEST')}ms)`
-        )
-      }
-
-      // Retry on network errors
-      if (retryCount < this.retryConfig.maxRetries) {
-        const delay = Math.min(
-          this.retryConfig.baseDelayMs * 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 (_error) {
-      // JSON parse error - use generic message (expected for non-JSON responses)
-      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

@@ -1,327 +0,0 @@
-/**
- * Sync Manager - Orchestrates push/pull operations
- *
- * Main entry point for sync operations.
- * Handles the coordination between local storage (EventBus) and remote API (SyncClient).
- */
-
-import eventBus from '../events'
-import type { IdeaPriority } from '../schemas/ideas'
-import type { Priority, TaskSection, TaskType } from '../schemas/state'
-import { ideasStorage } from '../storage/ideas-storage'
-import { queueStorage } from '../storage/queue-storage'
-import { shippedStorage } from '../storage/shipped-storage'
-import { stateStorage } from '../storage/state-storage'
-import type {
-  PullResult,
-  PushResult,
-  SyncBatchResult,
-  SyncPullResult,
-  SyncManagerResult as SyncResult,
-  SyncStatus,
-} from '../types'
-import authConfig from './auth-config'
-import { syncClient } from './sync-client'
-
-// ============================================
-// 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 (_error) {
-      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