@kbediako/codex-orchestrator 0.1.38 → 0.2.1

package/dist/orchestrator/src/cli/control/linearGraphqlClient.js

@@ -0,0 +1,150 @@
+import { createHash } from 'node:crypto';
+const LINEAR_GRAPHQL_URL = 'https://api.linear.app/graphql';
+const DEFAULT_LINEAR_REQUEST_TIMEOUT_MS = 30_000;
+const LINEAR_GRAPHQL_RELEVANT_RESPONSE_HEADERS = [
+    'retry-after',
+    'x-ratelimit-requests-limit',
+    'x-ratelimit-requests-remaining',
+    'x-ratelimit-requests-reset',
+    'x-ratelimit-endpoint-requests-limit',
+    'x-ratelimit-endpoint-requests-remaining',
+    'x-ratelimit-endpoint-requests-reset',
+    'x-ratelimit-endpoint-name',
+    'x-ratelimit-complexity-limit',
+    'x-ratelimit-complexity-remaining',
+    'x-ratelimit-complexity-reset',
+    'x-ratelimit-endpoint-complexity-limit',
+    'x-ratelimit-endpoint-complexity-remaining',
+    'x-ratelimit-endpoint-complexity-reset',
+    'x-complexity',
+    'x-request-id'
+];
+export async function executeLinearGraphql(input) {
+    const abortController = new AbortController();
+    const timeout = setTimeout(() => abortController.abort(), input.timeoutMs);
+    const response = await input.fetchImpl(LINEAR_GRAPHQL_URL, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: input.token
+        },
+        body: JSON.stringify({
+            query: input.query,
+            variables: input.variables ?? {}
+        }),
+        signal: abortController.signal
+    })
+        .catch(() => null)
+        .finally(() => clearTimeout(timeout));
+    if (!response) {
+        return {
+            ok: false,
+            failure: {
+                kind: 'request_failed',
+                status: null,
+                errors: []
+            }
+        };
+    }
+    const headers = readRelevantLinearGraphqlResponseHeaders(response);
+    const payload = await readLinearGraphqlPayload(response);
+    const errors = Array.isArray(payload?.errors) ? payload.errors : [];
+    if (!response.ok) {
+        if (errors.length > 0) {
+            return {
+                ok: false,
+                failure: {
+                    kind: 'graphql_error',
+                    status: response.status,
+                    errors,
+                    ...(headers ? { headers } : {})
+                }
+            };
+        }
+        return {
+            ok: false,
+            failure: {
+                kind: 'request_failed',
+                status: response.status,
+                errors: [],
+                ...(headers ? { headers } : {})
+            }
+        };
+    }
+    if (!payload) {
+        return {
+            ok: false,
+            failure: {
+                kind: 'response_invalid',
+                status: response.status,
+                errors: [],
+                ...(headers ? { headers } : {})
+            }
+        };
+    }
+    if (errors.length > 0) {
+        return {
+            ok: false,
+            failure: {
+                kind: 'graphql_error',
+                status: response.status,
+                errors,
+                ...(headers ? { headers } : {})
+            }
+        };
+    }
+    return {
+        ok: true,
+        payload,
+        ...(headers ? { headers } : {})
+    };
+}
+async function readLinearGraphqlPayload(response) {
+    let rawBody;
+    try {
+        rawBody = await response.text();
+    }
+    catch {
+        return null;
+    }
+    const trimmed = rawBody.trim();
+    if (trimmed.length === 0) {
+        return null;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+}
+function readRelevantLinearGraphqlResponseHeaders(response) {
+    const extracted = {};
+    for (const name of LINEAR_GRAPHQL_RELEVANT_RESPONSE_HEADERS) {
+        const value = response.headers.get(name);
+        if (typeof value === 'string' && value.trim().length > 0) {
+            extracted[name] = value.trim();
+        }
+    }
+    return Object.keys(extracted).length > 0 ? extracted : null;
+}
+export function resolveLinearApiToken(env) {
+    return (normalizeEnvValue(env.CO_LINEAR_API_TOKEN) ??
+        normalizeEnvValue(env.CO_LINEAR_API_KEY) ??
+        normalizeEnvValue(env.LINEAR_API_KEY));
+}
+export function resolveLinearApiTokenFingerprint(env) {
+    const token = resolveLinearApiToken(env);
+    return token ? createHash('sha256').update(token).digest('hex') : null;
+}
+export function resolveLinearRequestTimeoutMs(env) {
+    const raw = normalizeEnvValue(env.CO_LINEAR_REQUEST_TIMEOUT_MS);
+    if (!raw) {
+        return DEFAULT_LINEAR_REQUEST_TIMEOUT_MS;
+    }
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_LINEAR_REQUEST_TIMEOUT_MS;
+}
+function normalizeEnvValue(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
+}

package/dist/orchestrator/src/cli/control/linearRateLimit.js

@@ -0,0 +1,102 @@
+export function mapLinearRateLimitedFailure(failureValue) {
+    if (!isLinearRateLimitedFailure(failureValue)) {
+        return null;
+    }
+    return {
+        code: 'linear_rate_limited',
+        message: 'Linear API rate limit exceeded.',
+        status: 429,
+        retryable: true,
+        details: {
+            errors: serializeLinearGraphqlErrors(failureValue.errors),
+            ...extractLinearRateLimitDetailsFromHeaders(failureValue.headers)
+        }
+    };
+}
+export function extractLinearRateLimitDetailsFromHeaders(headers) {
+    const retryAfterSeconds = parsePositiveIntegerHeader(headers?.['retry-after']);
+    const requestsRemaining = parseIntegerHeader(headers?.['x-ratelimit-requests-remaining']);
+    const requestsLimit = parsePositiveIntegerHeader(headers?.['x-ratelimit-requests-limit']);
+    const requestsResetAt = parseLinearRateLimitResetHeader(headers?.['x-ratelimit-requests-reset']);
+    const endpointRequestsRemaining = parseIntegerHeader(headers?.['x-ratelimit-endpoint-requests-remaining']);
+    const endpointRequestsLimit = parsePositiveIntegerHeader(headers?.['x-ratelimit-endpoint-requests-limit']);
+    const endpointRequestsResetAt = parseLinearRateLimitResetHeader(headers?.['x-ratelimit-endpoint-requests-reset']);
+    const endpointName = normalizeOptionalString(headers?.['x-ratelimit-endpoint-name']);
+    const complexityRemaining = parseIntegerHeader(headers?.['x-ratelimit-complexity-remaining']);
+    const complexityLimit = parsePositiveIntegerHeader(headers?.['x-ratelimit-complexity-limit']);
+    const complexityResetAt = parseLinearRateLimitResetHeader(headers?.['x-ratelimit-complexity-reset']);
+    const endpointComplexityRemaining = parseIntegerHeader(headers?.['x-ratelimit-endpoint-complexity-remaining']);
+    const endpointComplexityLimit = parsePositiveIntegerHeader(headers?.['x-ratelimit-endpoint-complexity-limit']);
+    const endpointComplexityResetAt = parseLinearRateLimitResetHeader(headers?.['x-ratelimit-endpoint-complexity-reset']);
+    const requestComplexity = parsePositiveIntegerHeader(headers?.['x-complexity']);
+    const requestId = normalizeOptionalString(headers?.['x-request-id']);
+    return {
+        ...(retryAfterSeconds !== null ? { retry_after_seconds: retryAfterSeconds } : {}),
+        ...(requestsRemaining !== null ? { requests_remaining: requestsRemaining } : {}),
+        ...(requestsLimit !== null ? { requests_limit: requestsLimit } : {}),
+        ...(requestsResetAt !== null ? { requests_reset_at: requestsResetAt } : {}),
+        ...(endpointRequestsRemaining !== null ? { endpoint_requests_remaining: endpointRequestsRemaining } : {}),
+        ...(endpointRequestsLimit !== null ? { endpoint_requests_limit: endpointRequestsLimit } : {}),
+        ...(endpointRequestsResetAt !== null ? { endpoint_requests_reset_at: endpointRequestsResetAt } : {}),
+        ...(endpointName ? { endpoint_name: endpointName } : {}),
+        ...(complexityRemaining !== null ? { complexity_remaining: complexityRemaining } : {}),
+        ...(complexityLimit !== null ? { complexity_limit: complexityLimit } : {}),
+        ...(complexityResetAt !== null ? { complexity_reset_at: complexityResetAt } : {}),
+        ...(endpointComplexityRemaining !== null
+            ? { endpoint_complexity_remaining: endpointComplexityRemaining }
+            : {}),
+        ...(endpointComplexityLimit !== null ? { endpoint_complexity_limit: endpointComplexityLimit } : {}),
+        ...(endpointComplexityResetAt !== null ? { endpoint_complexity_reset_at: endpointComplexityResetAt } : {}),
+        ...(requestComplexity !== null ? { request_complexity: requestComplexity } : {}),
+        ...(requestId ? { request_id: requestId } : {})
+    };
+}
+function isLinearRateLimitedFailure(failureValue) {
+    return failureValue.errors.some((entry) => {
+        const message = normalizeOptionalString(entry.message)?.toLowerCase() ?? '';
+        const extensionCode = entry.extensions && typeof entry.extensions === 'object'
+            ? normalizeOptionalString(entry.extensions.code)?.toLowerCase() ?? ''
+            : '';
+        return extensionCode === 'ratelimited' || message.includes('rate limit exceeded');
+    });
+}
+function serializeLinearGraphqlErrors(errors) {
+    return errors.map((entry) => {
+        const path = Array.isArray(entry.path)
+            ? entry.path.filter((segment) => typeof segment === 'string' || (typeof segment === 'number' && Number.isFinite(segment)))
+            : [];
+        const extensions = entry.extensions && typeof entry.extensions === 'object'
+            ? { ...entry.extensions }
+            : null;
+        return {
+            message: normalizeOptionalString(entry.message) ?? 'unknown_error',
+            ...(path.length > 0 ? { path } : {}),
+            ...(extensions ? { extensions } : {})
+        };
+    });
+}
+function parseIntegerHeader(value) {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        return null;
+    }
+    const parsed = Number.parseInt(value, 10);
+    return Number.isInteger(parsed) ? parsed : null;
+}
+function parsePositiveIntegerHeader(value) {
+    const parsed = parseIntegerHeader(value);
+    return parsed !== null && parsed >= 0 ? parsed : null;
+}
+function parseLinearRateLimitResetHeader(value) {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        return null;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        return null;
+    }
+    const timestamp = new Date(parsed);
+    return Number.isNaN(timestamp.getTime()) ? null : timestamp.toISOString();
+}
+function normalizeOptionalString(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
+}