@edgedive/cli 0.2.1 → 0.3.1

package/src/api/client.ts

@@ -1,202 +0,0 @@
-/**
- * Edgedive API client for making authenticated requests
- */
-
-import axios, { AxiosInstance } from 'axios';
-import { API_CONFIG, TIMEOUTS } from '../constants.js';
-import { ConfigManager } from '../config/config-manager.js';
-import { OAuthFlow } from '../auth/oauth-flow.js';
-
-export interface TakeoverResponse {
-  session_id: string;
-  tenant_id: string;
-  repository: {
-    owner: string;
-    name: string;
-    branch: string;
-    base_branch: string;
-  };
-  github_pr: {
-    owner: string;
-    name: string;
-    number: number;
-    url: string;
-  };
-  linear_issue?: {
-    id: string;
-    identifier: string;
-    url: string;
-  };
-  asana_task?: {
-    gid: string;
-    url: string;
-  };
-  status: string;
-  agent_type: string;
-  download_urls: {
-    claude_session?: string;
-    session_metadata?: string;
-    messages?: string;
-  };
-  expires_in: number;
-  created_at: string;
-  updated_at: string;
-}
-
-export class EdgediveApiClient {
-  private client: AxiosInstance;
-  private configManager: ConfigManager;
-  private oauthFlow: OAuthFlow;
-  private isRefreshing: boolean = false;
-
-  constructor(configManager: ConfigManager) {
-    this.configManager = configManager;
-    this.oauthFlow = new OAuthFlow(configManager);
-    this.client = axios.create({
-      baseURL: API_CONFIG.BASE_URL,
-      timeout: TIMEOUTS.DEFAULT_REQUEST_MS,
-    });
-
-    // Add request interceptor to inject auth token and handle refresh
-    this.client.interceptors.request.use(async (config) => {
-      // Check if token needs refresh
-      const currentConfig = await this.configManager.load();
-
-      if (this.configManager.isTokenExpiringSoon(currentConfig) && !this.isRefreshing) {
-        this.isRefreshing = true;
-        try {
-          console.log('🔄 Access token expiring soon, refreshing...');
-          await this.oauthFlow.refreshAccessToken();
-          console.log('✅ Token refreshed successfully');
-        } catch (error: any) {
-          console.error('❌ Failed to refresh token:', error.message);
-          console.log('Please run "dive login" to re-authenticate');
-          throw error;
-        } finally {
-          this.isRefreshing = false;
-        }
-      }
-
-      const token = await this.configManager.getAccessToken();
-      if (token) {
-        config.headers.Authorization = `Bearer ${token}`;
-      }
-      return config;
-    });
-  }
-
-  /**
-   * Get session takeover information by PR URL
-   */
-  async getTakeoverByPrUrl(prUrl: string): Promise<TakeoverResponse> {
-    try {
-      const response = await this.client.get<TakeoverResponse>(API_CONFIG.TAKEOVER_PATH, {
-        params: { pr_url: prUrl },
-      });
-      return response.data;
-    } catch (error: any) {
-      if (error.response) {
-        const errorData = error.response.data;
-        throw new Error(errorData?.error || `API request failed: ${error.response.status}`);
-      }
-      throw new Error(`API request failed: ${error.message}`);
-    }
-  }
-
-  async getTakeoverByLinearIssueUrl(linearIssueUrl: string): Promise<TakeoverResponse> {
-    try {
-      const response = await this.client.get<TakeoverResponse>(API_CONFIG.TAKEOVER_PATH, {
-        params: {
-          linear_issue_url: linearIssueUrl,
-        },
-      });
-      return response.data;
-    } catch (error: any) {
-      if (error.response) {
-        const errorData = error.response.data;
-        throw new Error(errorData?.error || `API request failed: ${error.response.status}`);
-      }
-      throw new Error(`API request failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Get session takeover information by Slack thread URL
-   */
-  async getTakeoverBySlackThreadUrl(slackThreadUrl: string): Promise<TakeoverResponse> {
-    try {
-      const response = await this.client.get<TakeoverResponse>(API_CONFIG.TAKEOVER_PATH, {
-        params: {
-          slack_thread_url: slackThreadUrl,
-        },
-      });
-      return response.data;
-    } catch (error: any) {
-      if (error.response) {
-        const errorData = error.response.data;
-        throw new Error(errorData?.error || `API request failed: ${error.response.status}`);
-      }
-      throw new Error(`API request failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Get session takeover information by Asana task URL
-   */
-  async getTakeoverByAsanaTaskUrl(asanaTaskUrl: string): Promise<TakeoverResponse> {
-    try {
-      const response = await this.client.get<TakeoverResponse>(API_CONFIG.TAKEOVER_PATH, {
-        params: {
-          asana_task_url: asanaTaskUrl,
-        },
-      });
-      return response.data;
-    } catch (error: any) {
-      if (error.response) {
-        const errorData = error.response.data;
-        throw new Error(errorData?.error || `API request failed: ${error.response.status}`);
-      }
-      throw new Error(`API request failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Get session takeover information by session URL (share link)
-   */
-  async getTakeoverBySessionUrl(sessionUrl: string): Promise<TakeoverResponse> {
-    try {
-      const response = await this.client.get<TakeoverResponse>(API_CONFIG.TAKEOVER_PATH, {
-        params: {
-          session_url: sessionUrl,
-        },
-      });
-      return response.data;
-    } catch (error: any) {
-      if (error.response) {
-        const errorData = error.response.data;
-        throw new Error(errorData?.error || `API request failed: ${error.response.status}`);
-      }
-      throw new Error(`API request failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Upload Claude session file for an agent session
-   */
-  async uploadClaudeSession(sessionId: string, fileContent: Buffer): Promise<void> {
-    try {
-      const uploadPath = `/api/agents/agent-sessions/${sessionId}/claude-session`;
-      await this.client.put(uploadPath, fileContent, {
-        headers: {
-          'Content-Type': 'application/octet-stream',
-        },
-      });
-    } catch (error: any) {
-      if (error.response) {
-        const errorData = error.response.data;
-        throw new Error(errorData?.error || `Upload failed: ${error.response.status}`);
-      }
-      throw new Error(`Upload failed: ${error.message}`);
-    }
-  }
-}

package/src/auth/oauth-flow.ts

@@ -1,278 +0,0 @@
-/**
- * OAuth 2.0 authorization flow with PKCE
- */
-
-import http from 'http';
-import url from 'url';
-import axios from 'axios';
-import open from 'open';
-import { generateCodeChallenge, generateCodeVerifier } from './pkce.js';
-import { API_CONFIG, OAUTH_CONFIG, TIMEOUTS } from '../constants.js';
-import { ConfigManager } from '../config/config-manager.js';
-
-export interface OAuthTokenResponse {
-  access_token: string;
-  token_type: string;
-  expires_in: number;
-  scope: string;
-  refresh_token: string;
-}
-
-export class OAuthFlow {
-  private configManager: ConfigManager;
-
-  constructor(configManager: ConfigManager) {
-    this.configManager = configManager;
-  }
-
-  /**
-   * Initiate OAuth flow and wait for user authorization
-   */
-  async authorize(): Promise<OAuthTokenResponse> {
-    // Generate PKCE parameters
-    const codeVerifier = generateCodeVerifier();
-    const codeChallenge = generateCodeChallenge(codeVerifier);
-    const state = generateCodeVerifier(); // Use random string for state
-
-    // Build authorization URL
-    const authUrl = new URL(API_CONFIG.AUTHORIZE_PATH, API_CONFIG.BASE_URL);
-    authUrl.searchParams.set('client_id', OAUTH_CONFIG.CLIENT_ID);
-    authUrl.searchParams.set('redirect_uri', OAUTH_CONFIG.REDIRECT_URI);
-    authUrl.searchParams.set('code_challenge', codeChallenge);
-    authUrl.searchParams.set('state', state);
-    authUrl.searchParams.set('scope', 'read write');
-
-    console.log('\n🔐 Starting OAuth authorization flow...\n');
-    console.log('Opening browser for authorization...');
-    console.log(`If the browser doesn't open, visit: ${authUrl.toString()}\n`);
-
-    // Start local callback server
-    const authCode = await this.startCallbackServer(state, authUrl.toString());
-
-    // Exchange authorization code for access token
-    console.log('\n✅ Authorization successful! Exchanging code for token...\n');
-    const tokenResponse = await this.exchangeCodeForToken(authCode, codeVerifier);
-
-    // Save token to config
-    const expiresAt = Date.now() + tokenResponse.expires_in * 1000;
-    await this.configManager.save({
-      accessToken: tokenResponse.access_token,
-      tokenType: tokenResponse.token_type,
-      expiresAt,
-      scope: tokenResponse.scope,
-      refreshToken: tokenResponse.refresh_token,
-    });
-
-    return tokenResponse;
-  }
-
-  /**
-   * Start local HTTP server to receive OAuth callback
-   */
-  private async startCallbackServer(expectedState: string, authUrl: string): Promise<string> {
-    return new Promise((resolve, reject) => {
-      let resolved = false;
-      const timeout = setTimeout(() => {
-        if (!resolved) {
-          server.close();
-          reject(new Error('OAuth flow timed out'));
-        }
-      }, TIMEOUTS.CALLBACK_SERVER_MS);
-
-      const server = http.createServer((req, res) => {
-        if (!req.url) {
-          return;
-        }
-
-        const parsedUrl = url.parse(req.url, true);
-
-        if (parsedUrl.pathname === '/callback') {
-          const { code, state, error } = parsedUrl.query;
-
-          // Handle error response
-          if (error) {
-            resolved = true;
-            clearTimeout(timeout);
-            res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
-            res.end(`
-              <html>
-                <body>
-                  <h1>Authorization Failed</h1>
-                  <p>Error: ${error}</p>
-                  <p>You can close this window.</p>
-                </body>
-              </html>
-            `);
-            server.close();
-            reject(new Error(`OAuth error: ${error}`));
-            return;
-          }
-
-          // Validate state
-          if (state !== expectedState) {
-            resolved = true;
-            clearTimeout(timeout);
-            res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
-            res.end(`
-              <html>
-                <body>
-                  <h1>Authorization Failed</h1>
-                  <p>Invalid state parameter. Possible CSRF attack.</p>
-                  <p>You can close this window.</p>
-                </body>
-              </html>
-            `);
-            server.close();
-            reject(new Error('Invalid state parameter'));
-            return;
-          }
-
-          // Success - got authorization code
-          if (code && typeof code === 'string') {
-            resolved = true;
-            clearTimeout(timeout);
-            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-            res.end(`
-              <html>
-                <head>
-                  <meta charset="utf-8" />
-                </head>
-                <body>
-                  <h1>✅ Authorization Successful!</h1>
-                  <p>You can close this window and return to the terminal.</p>
-                  <script>setTimeout(() => window.close(), 2000);</script>
-                </body>
-              </html>
-            `);
-            server.close();
-            resolve(code);
-            return;
-          }
-
-          // Missing code
-          resolved = true;
-          clearTimeout(timeout);
-          res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
-          res.end(`
-            <html>
-              <body>
-                <h1>Authorization Failed</h1>
-                <p>Missing authorization code.</p>
-                <p>You can close this window.</p>
-              </body>
-            </html>
-          `);
-          server.close();
-          reject(new Error('Missing authorization code'));
-        }
-      });
-
-      server.listen(OAUTH_CONFIG.CALLBACK_PORT, () => {
-        // Open browser for authorization using the provided PKCE parameters
-        void open(authUrl, { wait: false })
-          .then((child) => {
-            if (child && typeof child.unref === 'function') {
-              child.unref();
-            }
-          })
-          .catch(() => {
-            // Silently fail if browser can't be opened
-          });
-      });
-
-      server.on('error', (err) => {
-        if (!resolved) {
-          resolved = true;
-          clearTimeout(timeout);
-          reject(err);
-        }
-      });
-    });
-  }
-
-  /**
-   * Exchange authorization code for access token
-   */
-  private async exchangeCodeForToken(
-    code: string,
-    codeVerifier: string
-  ): Promise<OAuthTokenResponse> {
-    try {
-      const tokenUrl = new URL(API_CONFIG.TOKEN_PATH, API_CONFIG.BASE_URL);
-
-      const response = await axios.post<OAuthTokenResponse>(
-        tokenUrl.toString(),
-        new URLSearchParams({
-          grant_type: 'authorization_code',
-          code,
-          code_verifier: codeVerifier,
-        }),
-        {
-          headers: {
-            'Content-Type': 'application/x-www-form-urlencoded',
-          },
-          timeout: TIMEOUTS.DEFAULT_REQUEST_MS,
-        }
-      );
-
-      return response.data;
-    } catch (error: any) {
-      if (error.response) {
-        throw new Error(
-          `Failed to exchange code for token: ${error.response.data?.error || error.message}`
-        );
-      }
-      throw new Error(`Failed to exchange code for token: ${error.message}`);
-    }
-  }
-
-  /**
-   * Refresh access token using refresh token
-   */
-  async refreshAccessToken(): Promise<OAuthTokenResponse | null> {
-    try {
-      const refreshToken = await this.configManager.getRefreshToken();
-      if (!refreshToken) {
-        return null;
-      }
-
-      const tokenUrl = new URL(API_CONFIG.TOKEN_PATH, API_CONFIG.BASE_URL);
-
-      const response = await axios.post<OAuthTokenResponse>(
-        tokenUrl.toString(),
-        new URLSearchParams({
-          grant_type: 'refresh_token',
-          refresh_token: refreshToken,
-        }),
-        {
-          headers: {
-            'Content-Type': 'application/x-www-form-urlencoded',
-          },
-          timeout: TIMEOUTS.DEFAULT_REQUEST_MS,
-        }
-      );
-
-      // Save new tokens to config
-      const expiresAt = Date.now() + response.data.expires_in * 1000;
-      await this.configManager.save({
-        accessToken: response.data.access_token,
-        tokenType: response.data.token_type,
-        expiresAt,
-        scope: response.data.scope,
-        refreshToken: response.data.refresh_token,
-      });
-
-      return response.data;
-    } catch (error: any) {
-      // If refresh fails, clear the config so user needs to login again
-      await this.configManager.delete();
-
-      if (error.response) {
-        throw new Error(
-          `Failed to refresh token: ${error.response.data?.error || error.message}`
-        );
-      }
-      throw new Error(`Failed to refresh token: ${error.message}`);
-    }
-  }
-}

package/src/auth/pkce.ts

@@ -1,27 +0,0 @@
-/**
- * PKCE (Proof Key for Code Exchange) utilities for OAuth 2.0
- */
-
-import crypto from 'crypto';
-
-/**
- * Generate a cryptographically random code verifier
- */
-export function generateCodeVerifier(): string {
-  return base64URLEncode(crypto.randomBytes(32));
-}
-
-/**
- * Generate a code challenge from a code verifier using SHA256
- */
-export function generateCodeChallenge(verifier: string): string {
-  const hash = crypto.createHash('sha256').update(verifier).digest();
-  return base64URLEncode(hash);
-}
-
-/**
- * Base64 URL encode (without padding)
- */
-function base64URLEncode(buffer: Buffer): string {
-  return buffer.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
-}