Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
5.1 KB
Raw Blame
import { appLogger } from "./observability/logger.js"

export type LinearConfig = {
  apiKey?: string
  teamId?: string
  apiBase: string
  completedStateId?: string
}

export type LinearIssue = {
  id: string
  identifier?: string
  url?: string
}

export type CreateLinearIssueInput = {
  title: string
  description: string
  teamId?: string
  stateId?: string
  labelIds?: string[]
  priority?: number
}

export type CompleteLinearIssueInput = {
  issueId: string
  completedStateId?: string
}

const logger = appLogger.child({ component: "linear" })

const ISSUE_CREATE_MUTATION = `
mutation OmniRushIssueCreate($input: IssueCreateInput!) {
  issueCreate(input: $input) {
    success
    issue {
      id
      identifier
      url
    }
  }
}`

const ISSUE_COMPLETE_MUTATION = `
mutation OmniRushIssueComplete($id: String!, $input: IssueUpdateInput!) {
  issueUpdate(id: $id, input: $input) {
    success
    issue {
      id
      identifier
      url
    }
  }
}`

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === "object" && value !== null
}

function optionalString(value: unknown) {
  return typeof value === "string" && value.trim() ? value : undefined
}

function parseJson(text: string): unknown {
  if (!text.trim()) {
    return null
  }
  return JSON.parse(text)
}

function graphqlErrorMessages(payload: unknown) {
  if (!isRecord(payload) || !Array.isArray(payload.errors)) {
    return []
  }

  const messages: string[] = []
  for (const error of payload.errors) {
    if (isRecord(error) && typeof error.message === "string" && error.message.trim()) {
      messages.push(error.message)
    }
  }
  return messages
}

function recordField(record: Record<string, unknown> | null, key: string) {
  const value = record?.[key]
  return isRecord(value) ? value : null
}

function parseLinearIssue(value: unknown): LinearIssue | null {
  if (!isRecord(value) || typeof value.id !== "string" || !value.id.trim()) {
    return null
  }

  return {
    id: value.id,
    identifier: optionalString(value.identifier),
    url: optionalString(value.url),
  }
}

async function linearGraphql(config: LinearConfig, query: string, variables: Record<string, unknown>) {
  const apiKey = config.apiKey?.trim()
  if (!apiKey) {
    throw new Error("LINEAR_API_KEY is not configured")
  }

  const apiBase = config.apiBase.trim()
  if (!apiBase) {
    throw new Error("LINEAR_API_BASE is empty")
  }

  const response = await fetch(apiBase, {
    method: "POST",
    headers: {
      Authorization: apiKey,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ query, variables }),
  })
  const text = await response.text()
  const payload = parseJson(text)

  if (!response.ok) {
    throw new Error(`Linear GraphQL request failed (${response.status}): ${text.slice(0, 400)}`)
  }

  const errors = graphqlErrorMessages(payload)
  if (errors.length > 0) {
    throw new Error(`Linear GraphQL error: ${errors.join("; ")}`)
  }

  return payload
}

async function createLinearIssueStrict(input: CreateLinearIssueInput & { teamId: string }, config: LinearConfig) {
  const issueInput: Record<string, unknown> = {
    teamId: input.teamId,
    title: input.title,
    description: input.description,
  }
  if (input.stateId) {
    issueInput.stateId = input.stateId
  }
  if (input.labelIds?.length) {
    issueInput.labelIds = input.labelIds
  }
  if (input.priority !== undefined) {
    issueInput.priority = input.priority
  }

  const payload = await linearGraphql(config, ISSUE_CREATE_MUTATION, { input: issueInput })
  const data = recordField(isRecord(payload) ? payload : null, "data")
  const issueCreate = recordField(data, "issueCreate")
  if (issueCreate?.success !== true) {
    return null
  }
  return parseLinearIssue(issueCreate.issue)
}

async function completeLinearIssueStrict(input: { issueId: string; completedStateId: string }, config: LinearConfig) {
  const payload = await linearGraphql(config, ISSUE_COMPLETE_MUTATION, {
    id: input.issueId,
    input: { stateId: input.completedStateId },
  })
  const data = recordField(isRecord(payload) ? payload : null, "data")
  const issueUpdate = recordField(data, "issueUpdate")
  return issueUpdate?.success === true
}

export async function createLinearIssue(input: CreateLinearIssueInput, config: LinearConfig): Promise<LinearIssue | null> {
  const teamId = input.teamId ?? config.teamId
  if (!config.apiKey || !teamId) {
    return null
  }

  try {
    return await createLinearIssueStrict({ ...input, teamId }, config)
  } catch (error) {
    logger.warn("failed to create Linear issue", { error })
    return null
  }
}

export async function completeLinearIssue(input: CompleteLinearIssueInput, config: LinearConfig) {
  const issueId = input.issueId.trim()
  const completedStateId = input.completedStateId ?? config.completedStateId
  if (!config.apiKey || !completedStateId || !issueId) {
    return false
  }

  try {
    return await completeLinearIssueStrict({ issueId, completedStateId }, config)
  } catch (error) {
    logger.warn("failed to complete Linear issue", { error, issue_id: issueId })
    return false
  }
}