prjct-cli 0.17.0 → 0.18.1

package/core/sync/oauth-handler.ts

@@ -0,0 +1,148 @@
+/**
+ * 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 { authConfig } from './auth-config'
+import { syncClient } from './sync-client'
+
+export interface AuthResult {
+  success: boolean
+  email?: string
+  error?: string
+}
+
+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 {
+      // 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('child_process')
+    const { promisify } = await import('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

@@ -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