commitea/apps/desktop/src/main/gitea.ts

/**
 * Main-process gitea bridge. All gitea traffic runs here — the token never
 * reaches the renderer (which is CSP-locked to 'self' anyway). The renderer
 * calls these over IPC (see preload). Config for the dogfood slice comes from
 * the environment or the repo's .env.local; Settings/Onboarding wire it up
 * properly later.
 */

import { readFileSync } from 'node:fs'
import { dirname, join } from 'node:path'

import {
  createGiteaClient,
  type GiteaConfig,
  type GiteaLabel,
  type IssueChange,
  type LifecycleEvent,
  planIssueChange,
} from '@commitea/core'
import { ipcMain } from 'electron'

/** Walk up from cwd looking for a .env.local with a GITEA_TOKEN (dev convenience). */
function loadEnvLocalToken(): string | undefined {
  let dir = process.cwd()
  for (let i = 0; i < 6; i++) {
    try {
      const txt = readFileSync(join(dir, '.env.local'), 'utf8')
      const m = /^GITEA_TOKEN\s*=\s*(.+?)\s*$/m.exec(txt)
      if (m) return m[1].trim()
    } catch {
      // not in this dir — keep walking up
    }
    const parent = dirname(dir)
    if (parent === dir) break
    dir = parent
  }
  return undefined
}

function resolveConfig(): GiteaConfig | null {
  // E2E runs against fixtures — never hit the network from the test harness.
  if (process.env.COMMITEA_E2E === '1') return null
  const token = process.env.GITEA_TOKEN ?? loadEnvLocalToken()
  if (!token) return null
  return {
    baseUrl: process.env.GITEA_BASE_URL ?? 'https://gitea.stephenmann.io',
    token,
    owner: process.env.GITEA_OWNER ?? 'christian',
    repo: process.env.GITEA_REPO ?? 'commitea',
  }
}

export function registerGiteaIpc(): void {
  const config = resolveConfig()
  const client = config ? createGiteaClient(config, fetch) : null
  const repo = config ? `${config.owner}/${config.repo}` : null

  ipcMain.handle('gitea:status', () => ({ configured: !!config, repo }))

  ipcMain.handle('gitea:reconcile', async () => {
    if (!client) return { configured: false, issues: [], milestones: [], deps: [], timelines: {} }
    const [issues, milestones] = await Promise.all([client.listIssues(), client.listMilestones()])
    // dependency edges among the open scope (the scheduler only plans what's left)
    const open = issues.filter((i) => i.state === 'open')
    const perIssue = await Promise.all(
      open.map(async (i) => ({ issue: i.number, dependsOn: await client.getIssueDependencies(i.number) })),
    )
    const deps = perIssue.flatMap(({ issue, dependsOn }) => dependsOn.map((d) => ({ issue, dependsOn: d })))
    // lifecycle timelines for every issue (open → columns/badges, closed → calibration actuals)
    const timelineEntries = await Promise.all(
      issues.map(async (i) => [i.number, await client.getIssueTimeline(i.number)] as const),
    )
    const timelines: Record<number, LifecycleEvent[]> = Object.fromEntries(timelineEntries)
    return { configured: true, issues, milestones, deps, timelines }
  })

  ipcMain.handle('gitea:getIssue', async (_event, index: number) => {
    if (!client) return null
    return client.getIssue(index)
  })

  // Cached label list for name→id resolution; refreshed on demand if a name misses.
  let labelCache: GiteaLabel[] | null = null
  async function resolveLabelIds(names: string[]): Promise<number[]> {
    if (!client) return []
    const lookup = () => new Map(labelCache!.map((l) => [l.name, l.id]))
    if (!labelCache) labelCache = await client.listLabels()
    let byName = lookup()
    if (names.some((n) => !byName.has(n))) {
      labelCache = await client.listLabels() // a name we don't know — refetch once
      byName = lookup()
    }
    return names.map((n) => byName.get(n)).filter((id): id is number => id != null)
  }

  // The write path (apply_changes). Additive label swaps, applied only after the
  // renderer's propose-approve. Returns the plan + the freshly-read issue.
  ipcMain.handle('gitea:applyChange', async (_event, change: IssueChange) => {
    if (!client) return { ok: false as const, reason: 'unconfigured' as const }
    const current = await client.getIssue(change.issue)
    const plan = planIssueChange(current.labels, change)
    if (plan.noop) return { ok: true as const, plan, issue: current }
    const ids = await resolveLabelIds(plan.labels)
    await client.setIssueLabels(change.issue, ids)
    const issue = await client.getIssue(change.issue)
    return { ok: true as const, plan, issue }
  })
}