relay-ide 0.1.0

package/dist/server/github-app.js

@@ -0,0 +1,218 @@
+import { Router } from 'express';
+import { loadConfig, saveConfig } from './config.js';
+import { createLogger } from './logger.js';
+const logger = createLogger('github-app');
+let deviceFlow = {
+    generation: 0,
+    deviceCode: '',
+    interval: 5,
+    timerId: null,
+    flowStatus: null,
+    pollInFlight: false,
+};
+/** Test helper — returns the current device flow state. */
+export function _getDeviceFlowState() {
+    return deviceFlow;
+}
+function stopPollTimer() {
+    if (deviceFlow.timerId !== null) {
+        clearInterval(deviceFlow.timerId);
+        deviceFlow.timerId = null;
+    }
+}
+/**
+ * Creates and returns an Express Router that handles all /auth/github routes.
+ *
+ * Caller is responsible for mounting and applying auth middleware:
+ *   app.use('/auth/github', requireAuth, createGitHubAppRouter({ configPath, clientId }));
+ */
+export function createGitHubAppRouter(deps) {
+    const { configPath, clientId } = deps;
+    const fetchFn = deps.fetchFn ?? globalThis.fetch;
+    const router = Router();
+    function getConfig() {
+        return loadConfig(configPath);
+    }
+    // GET / — Initiate GitHub Device Flow
+    router.get('/', async (_req, res) => {
+        // Cancel any existing poll timer and increment generation
+        stopPollTimer();
+        deviceFlow.generation += 1;
+        deviceFlow.flowStatus = null; // Reset stale status from prior flow
+        const generation = deviceFlow.generation;
+        // POST to GitHub device/code endpoint
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 10_000);
+        let deviceCodeData;
+        try {
+            const codeRes = await fetchFn('https://github.com/login/device/code', {
+                method: 'POST',
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    client_id: clientId,
+                    scope: 'repo admin:repo_hook',
+                }),
+                signal: controller.signal,
+            });
+            if (!codeRes.ok) {
+                res.status(500).json({ error: 'Failed to initiate device flow' });
+                return;
+            }
+            deviceCodeData = (await codeRes.json());
+        }
+        catch {
+            res.status(500).json({ error: 'Failed to initiate device flow' });
+            return;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+        // Store device code and start polling
+        deviceFlow.deviceCode = deviceCodeData.device_code;
+        deviceFlow.interval = Math.max(deviceCodeData.interval ?? 5, 1);
+        deviceFlow.flowStatus = 'polling';
+        deviceFlow.timerId = setInterval(() => void poll(generation, configPath, clientId, fetchFn, deps.onConnected), deviceFlow.interval * 1000);
+        res.json({
+            userCode: deviceCodeData.user_code,
+            verificationUri: deviceCodeData.verification_uri,
+            expiresIn: deviceCodeData.expires_in,
+        });
+    });
+    // GET /status — Return { connected, username, deviceFlowStatus? } from config
+    router.get('/status', (_req, res) => {
+        const config = getConfig();
+        const github = config.github;
+        const connected = Boolean(github?.accessToken);
+        const username = github?.username ?? null;
+        res.json({
+            connected,
+            username,
+            ...(deviceFlow.flowStatus
+                ? { deviceFlowStatus: deviceFlow.flowStatus }
+                : {}),
+        });
+    });
+    // POST /disconnect — Remove accessToken and username from config.github (preserve webhookSecret and smeeUrl)
+    router.post('/disconnect', (_req, res) => {
+        const config = getConfig();
+        if (config.github) {
+            delete config.github.accessToken;
+            delete config.github.username;
+        }
+        saveConfig(configPath, config);
+        // Cancel any in-progress device-flow polling and invalidate the current flow
+        stopPollTimer();
+        deviceFlow.generation += 1;
+        deviceFlow.deviceCode = '';
+        deviceFlow.flowStatus = null;
+        res.json({ ok: true });
+    });
+    return router;
+}
+async function poll(generation, configPath, clientId, fetchFn, onConnected) {
+    // Generation check — abort if a newer flow has started
+    if (deviceFlow.generation !== generation)
+        return;
+    // In-flight guard — skip if previous poll hasn't finished (prevents overlap when request takes > interval)
+    if (deviceFlow.pollInFlight)
+        return;
+    deviceFlow.pollInFlight = true;
+    try {
+        let data;
+        const pollController = new AbortController();
+        const pollTimeoutId = setTimeout(() => pollController.abort(), 10_000);
+        try {
+            const res = await fetchFn('https://github.com/login/oauth/access_token', {
+                method: 'POST',
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    client_id: clientId,
+                    device_code: deviceFlow.deviceCode,
+                    grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+                }),
+                signal: pollController.signal,
+            });
+            data = (await res.json());
+        }
+        catch (err) {
+            logger.warn('Device flow poll network error:', err);
+            return;
+        }
+        finally {
+            clearTimeout(pollTimeoutId);
+        }
+        // Re-check generation after await
+        if (deviceFlow.generation !== generation)
+            return;
+        if (data['error'] === 'authorization_pending') {
+            // No-op — keep polling
+            return;
+        }
+        if (data['error'] === 'slow_down') {
+            // Re-check generation before restarting timer
+            if (deviceFlow.generation !== generation)
+                return;
+            // Clear timer and restart with increased interval (do NOT increment generation)
+            stopPollTimer();
+            deviceFlow.interval += 5;
+            deviceFlow.timerId = setInterval(() => void poll(generation, configPath, clientId, fetchFn, onConnected), deviceFlow.interval * 1000);
+            return;
+        }
+        if (data['error'] === 'expired_token') {
+            stopPollTimer();
+            deviceFlow.flowStatus = 'expired';
+            return;
+        }
+        if (data['error'] === 'access_denied') {
+            stopPollTimer();
+            deviceFlow.flowStatus = 'denied';
+            return;
+        }
+        if (data['access_token']) {
+            const accessToken = data['access_token'];
+            // Fetch username via GraphQL (best-effort)
+            let username;
+            try {
+                const gqlRes = await fetchFn('https://api.github.com/graphql', {
+                    method: 'POST',
+                    headers: {
+                        Authorization: `bearer ${accessToken}`,
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ query: '{ viewer { login } }' }),
+                });
+                if (gqlRes.ok) {
+                    const gqlData = (await gqlRes.json());
+                    username = gqlData.data?.viewer?.login ?? undefined;
+                }
+            }
+            catch {
+                // Best-effort — username stays undefined
+            }
+            // Save token to config first, then username (best-effort)
+            const config = loadConfig(configPath);
+            if (!config.github)
+                config.github = {};
+            config.github.accessToken = accessToken;
+            if (username)
+                config.github.username = username;
+            saveConfig(configPath, config);
+            // Clear timer and mark flow complete
+            stopPollTimer();
+            deviceFlow.flowStatus = null;
+            onConnected?.();
+            return;
+        }
+        // Unknown response
+        logger.warn('Unknown device flow poll response', data);
+    }
+    finally {
+        deviceFlow.pollInFlight = false;
+    }
+}

package/dist/server/github-graphql.js

@@ -0,0 +1,178 @@
+/**
+ * GitHub GraphQL client for fetching pull requests involving the current user.
+ *
+ * Provides:
+ *   buildPrSearchQuery()    — GraphQL query string
+ *   mapGraphQLResponse()    — maps raw response to PullRequest[]
+ *   fetchPrsGraphQL()       — fetches from GitHub GraphQL API
+ */
+import { createLogger } from './logger.js';
+const logger = createLogger('github-graphql');
+// ─── GraphQL query ────────────────────────────────────────────────────────────
+/**
+ * Returns the GraphQL query string for searching PRs involving the current user.
+ */
+export function buildPrSearchQuery() {
+    return `
+    query InvolvedPRs($query: String!) {
+      search(query: $query, type: ISSUE, first: 100) {
+        nodes {
+          ... on PullRequest {
+            number
+            title
+            state
+            isDraft
+            url
+            updatedAt
+            createdAt
+            author {
+              login
+            }
+            headRefName
+            baseRefName
+            repository {
+              nameWithOwner
+            }
+            reviewDecision
+            reviewRequests(first: 20) {
+              nodes {
+                requestedReviewer {
+                  ... on User {
+                    login
+                  }
+                }
+              }
+            }
+            commits(last: 1) {
+              nodes {
+                commit {
+                  statusCheckRollup {
+                    state
+                  }
+                }
+              }
+            }
+            mergeable
+            additions
+            deletions
+          }
+        }
+      }
+      viewer {
+        login
+      }
+    }
+  `.trim();
+}
+// ─── Response mapper ──────────────────────────────────────────────────────────
+/**
+ * Maps a raw GitHub GraphQL response to a list of PullRequest objects.
+ *
+ * @param response - The raw GraphQL response from GitHub
+ * @param repoMap  - Map of "owner/repo" (lowercased) → local workspace path
+ * @returns { prs, username } — filtered and mapped PR list plus authenticated username
+ */
+export function mapGraphQLResponse(response, repoMap) {
+    const username = response.data.viewer.login;
+    const nodes = response.data.search.nodes;
+    const prs = [];
+    for (const node of nodes) {
+        // Type guard: only process PullRequest nodes (not Issue nodes)
+        if (!('number' in node) || !('headRefName' in node))
+            continue;
+        const pr = node;
+        const nameWithOwner = pr.repository.nameWithOwner.toLowerCase();
+        const wsPath = repoMap.get(nameWithOwner);
+        if (!wsPath)
+            continue;
+        const author = pr.author?.login ?? '';
+        const isAuthor = author === username;
+        const isReviewer = !isAuthor &&
+            pr.reviewRequests.nodes.some((rr) => rr.requestedReviewer?.login === username);
+        if (!isAuthor && !isReviewer)
+            continue;
+        const role = isAuthor ? 'author' : 'reviewer';
+        // Extract CI status from last commit's statusCheckRollup
+        const lastCommit = pr.commits.nodes[0];
+        const rollupState = lastCommit?.commit?.statusCheckRollup?.state ?? null;
+        let ciStatus = null;
+        if (rollupState === 'SUCCESS')
+            ciStatus = 'SUCCESS';
+        else if (rollupState === 'FAILURE')
+            ciStatus = 'FAILURE';
+        else if (rollupState === 'ERROR')
+            ciStatus = 'ERROR';
+        else if (rollupState === 'PENDING' || rollupState === 'EXPECTED')
+            ciStatus = 'PENDING';
+        // Derive repoName from the nameWithOwner (the part after the slash)
+        const repoName = pr.repository.nameWithOwner.split('/')[1] ?? pr.repository.nameWithOwner;
+        // Map state
+        let state;
+        if (pr.state === 'OPEN')
+            state = 'OPEN';
+        else if (pr.state === 'MERGED')
+            state = 'MERGED';
+        else
+            state = 'CLOSED';
+        prs.push({
+            number: pr.number,
+            title: pr.title,
+            url: pr.url,
+            headRefName: pr.headRefName,
+            baseRefName: pr.baseRefName,
+            state,
+            author,
+            role,
+            updatedAt: pr.updatedAt,
+            additions: pr.additions,
+            deletions: pr.deletions,
+            reviewDecision: pr.reviewDecision,
+            mergeable: pr.mergeable,
+            ciStatus,
+            isDraft: pr.isDraft,
+            repoName,
+            repoPath: wsPath,
+        });
+    }
+    return { prs, username };
+}
+// ─── Fetch function ───────────────────────────────────────────────────────────
+const GITHUB_GRAPHQL_URL = 'https://api.github.com/graphql';
+/**
+ * Fetches pull requests from the GitHub GraphQL API.
+ *
+ * @param token    - GitHub personal access token (Bearer)
+ * @param repoMap  - Map of "owner/repo" (lowercased) → local workspace path
+ * @param fetchFn  - Optional fetch implementation (defaults to global fetch); injectable for testing
+ * @returns { prs, username }
+ * @throws Error on non-2xx HTTP responses
+ */
+export async function fetchPrsGraphQL(token, repoMap, fetchFn = fetch) {
+    const query = buildPrSearchQuery();
+    const variables = { query: 'is:pr is:open involves:@me' };
+    const response = await fetchFn(GITHUB_GRAPHQL_URL, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${token}`,
+            'User-Agent': 'relay-ide',
+        },
+        body: JSON.stringify({ query, variables }),
+    });
+    if (!response.ok) {
+        throw new Error(`GitHub GraphQL request failed: ${response.status} ${response.statusText}`);
+    }
+    const json = (await response.json());
+    // GitHub GraphQL returns HTTP 200 even for errors (expired tokens, insufficient scopes)
+    if (json.errors && !json.data) {
+        throw new Error(`GitHub GraphQL error: ${json.errors[0]?.message ?? 'unknown'}`);
+    }
+    if (json.errors) {
+        // Partial errors: data is present but some fields failed — log and continue
+        logger.warn('[github-graphql] GraphQL returned partial errors:', json.errors.map((e) => e.message).join('; '));
+    }
+    if (!json.data) {
+        throw new Error('GitHub GraphQL returned no data');
+    }
+    return mapGraphQLResponse({ data: json.data }, repoMap);
+}