@allbluecn/admin-app 0.1.0

package/src/server/__tests__/admin-ai-alerts.test.ts

@@ -0,0 +1,113 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+vi.mock('@allbluecn/database', () => ({
+  prisma: {
+    aiUsageLog: {
+      count: vi.fn(),
+      findMany: vi.fn(),
+      groupBy: vi.fn(),
+    },
+  },
+}))
+
+import { checkAiAlerts, getAiAlertSummary } from '../admin-ai-alerts'
+import { prisma } from '@allbluecn/database'
+
+const getMock = () =>
+  (prisma.aiUsageLog as unknown) as {
+    count: ReturnType<typeof vi.fn>
+    findMany: ReturnType<typeof vi.fn>
+    groupBy: ReturnType<typeof vi.fn>
+  }
+
+describe('AI 异常告警检测', () => {
+  beforeEach(() => { vi.clearAllMocks() })
+
+  it('无调用日志时返回空告警', async () => {
+    getMock().count.mockResolvedValue(0)
+    getMock().findMany.mockResolvedValue([])
+
+    const alerts = await checkAiAlerts()
+    expect(alerts).toEqual([])
+  })
+
+  it('错误率超过阈值触发 error_spike 告警', async () => {
+    getMock().count
+      .mockResolvedValueOnce(100)
+      .mockResolvedValueOnce(15)
+    getMock().findMany.mockResolvedValue(
+      Array.from({ length: 15 }, () => ({
+        provider: 'openrouter',
+        model: 'gpt-4o',
+        errorMessage: 'timeout',
+        workspaceId: 'ws1',
+        userId: 'u1',
+        createdAt: new Date(),
+      })),
+    )
+
+    const alerts = await checkAiAlerts({ errorRateThreshold: 0.05 })
+    const errorAlert = alerts.find((a) => a.type === 'error_spike')
+    expect(errorAlert).toBeDefined()
+    expect(errorAlert?.severity).toBe('warning')
+  })
+
+  it('单日成本超阈值触发 high_cost 告警', async () => {
+    getMock().count.mockResolvedValue(100)
+    getMock().findMany.mockResolvedValue([
+      { createdAt: new Date('2026-08-11T00:00:00Z'), costUsd: 40 },
+      { createdAt: new Date('2026-08-11T01:00:00Z'), costUsd: 40 },
+      { createdAt: new Date('2026-08-12T00:00:00Z'), costUsd: 30 },
+    ])
+
+    const alerts = await checkAiAlerts({ dailyCostThresholdUsd: 50 })
+    const costAlert = alerts.find((a) => a.type === 'high_cost')
+    expect(costAlert).toBeDefined()
+    expect(costAlert?.value).toBe(80)
+  })
+
+  it('getAiAlertSummary 聚合告警统计', async () => {
+    getMock().count.mockResolvedValue(0)
+    getMock().findMany.mockResolvedValue([])
+
+    const summary = await getAiAlertSummary()
+    expect(summary.totalAlerts).toBe(0)
+    expect(summary.bySeverity.warning).toBe(0)
+    expect(summary.bySeverity.critical).toBe(0)
+    expect(summary.byType).toEqual([])
+  })
+
+  it('单 workspace 单日调用超阈值触发 quota_exhausted 告警', async () => {
+    getMock().count.mockResolvedValue(250)
+    getMock().findMany.mockResolvedValue(
+      Array.from({ length: 250 }, () => ({
+        workspaceId: 'ws-heavy',
+        createdAt: new Date('2026-08-11T00:00:00Z'),
+        costUsd: 0.01,
+      })),
+    )
+
+    const alerts = await checkAiAlerts({ workspaceDailyCallsThreshold: 200 })
+    const quotaAlert = alerts.find((a) => a.type === 'quota_exhausted')
+    expect(quotaAlert).toBeDefined()
+    expect(quotaAlert?.count).toBe(250)
+    expect(quotaAlert?.workspaceId).toBe('ws-heavy')
+    expect(quotaAlert?.severity).toBe('warning')
+  })
+
+  it('默认单日成本阈值对齐设计规格 $10（env 未设时）', async () => {
+    const prev = process.env.HOSTED_AI_DAILY_ALERT_THRESHOLD_USD
+    delete process.env.HOSTED_AI_DAILY_ALERT_THRESHOLD_USD
+    getMock().count.mockResolvedValue(100)
+    getMock().findMany.mockResolvedValue([
+      { workspaceId: 'ws1', createdAt: new Date('2026-08-11T00:00:00Z'), costUsd: 15 },
+    ])
+
+    const alerts = await checkAiAlerts()
+    const costAlert = alerts.find((a) => a.type === 'high_cost')
+    expect(costAlert).toBeDefined()
+    expect(costAlert?.threshold).toBe(10)
+
+    if (prev !== undefined) process.env.HOSTED_AI_DAILY_ALERT_THRESHOLD_USD = prev
+  })
+})

package/src/server/__tests__/licenses-issue.test.ts

@@ -0,0 +1,98 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+let currentIssueFn: unknown = vi.fn()
+let currentVerifyFn: ReturnType<typeof vi.fn> = vi.fn()
+
+vi.mock('@/server/pro-services', () => ({
+  getProService: (key: string) =>
+    key === 'license'
+      ? {
+          verify: currentVerifyFn,
+          issue: currentIssueFn as ReturnType<typeof vi.fn>,
+        }
+      : null,
+  isProEdition: () => false,
+}))
+vi.mock('@/server/auth-helpers', () => ({
+  requireAdmin: vi.fn().mockResolvedValue({ user: { id: 'admin1' } }),
+}))
+vi.mock('@allbluecn/database', () => ({
+  prisma: {
+    licenseKey: {
+      findMany: vi.fn(),
+      count: vi.fn(),
+      findUnique: vi.fn(),
+      update: vi.fn(),
+      create: vi.fn().mockResolvedValue({}),
+    },
+  },
+}))
+
+import { issueLicense } from '@/server/license-issue'
+import { prisma } from '@allbluecn/database'
+
+const validInput = {
+  customerName: '某公司',
+  customerEmail: 'ops@example.com',
+  customerId: 'cust-001',
+  plan: 'enterprise',
+  seats: 50,
+  features: { hostedAi: true },
+  expiresAt: null,
+}
+
+const getPrismaCreate = () =>
+  (prisma.licenseKey as unknown as { create: ReturnType<typeof vi.fn> }).create
+
+describe('issueLicense', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    currentIssueFn = vi.fn()
+    currentVerifyFn = vi.fn()
+  })
+
+  it('合法输入 → 调 license.issue + 落库 LicenseKey + 返回 key', async () => {
+    currentIssueFn = vi.fn().mockResolvedValue({
+      key: 'payload.sig',
+      signature: 'sig',
+      payload: {
+        seats: 50,
+        plan: 'enterprise',
+        issuedAt: '2026-01-01T00:00:00.000Z',
+        expiresAt: null,
+      },
+    })
+    const result = await issueLicense(validInput)
+    expect(result).toMatchObject({ key: 'payload.sig' })
+    expect(currentIssueFn).toHaveBeenCalledWith(
+      expect.objectContaining({ customerName: '某公司', seats: 50 }),
+    )
+    expect(getPrismaCreate()).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          customerId: 'cust-001',
+          customerName: '某公司',
+          seats: 50,
+          plan: 'enterprise',
+        }),
+      }),
+    )
+  })
+
+  it('features 含未注册 key → 拒绝（C1 防线）', async () => {
+    await expect(
+      issueLicense({ ...validInput, features: { notInRegistry: true } }),
+    ).rejects.toMatchObject({
+      message: expect.stringContaining('未注册'),
+    })
+    expect(currentIssueFn).not.toHaveBeenCalled()
+    expect(getPrismaCreate()).not.toHaveBeenCalled()
+  })
+
+  it('Pro 未实现 issue（OSS）→ 报错', async () => {
+    currentIssueFn = undefined
+    await expect(issueLicense(validInput)).rejects.toMatchObject({
+      message: expect.stringContaining('签发'),
+    })
+  })
+})

package/src/server/admin-ai-alerts.ts

@@ -0,0 +1,177 @@
+import { prisma } from '@allbluecn/database'
+
+export interface AiAlert {
+  type: 'quota_exhausted' | 'high_cost' | 'error_spike' | 'provider_failure'
+  severity: 'warning' | 'critical'
+  message: string
+  workspaceId?: string
+  workspaceName?: string
+  userId?: string
+  userName?: string
+  metric: string
+  value: number
+  threshold: number
+  period: string
+  count: number
+  createdAt: Date
+}
+
+export interface AlertSummary {
+  totalAlerts: number
+  bySeverity: { warning: number; critical: number }
+  byType: Array<{ type: string; count: number }>
+  alerts: AiAlert[]
+}
+
+export interface AlertCheckOptions {
+  hours?: number
+  errorRateThreshold?: number
+  dailyCostThresholdUsd?: number
+  workspaceDailyCallsThreshold?: number
+}
+
+export async function checkAiAlerts(options: AlertCheckOptions = {}): Promise<AiAlert[]> {
+  const { hours = 24, errorRateThreshold = 0.05 } = options
+  const dailyCostThresholdUsd =
+    options.dailyCostThresholdUsd ??
+    (Number(process.env.HOSTED_AI_DAILY_ALERT_THRESHOLD_USD) || 10)
+  const workspaceDailyCallsThreshold =
+    options.workspaceDailyCallsThreshold ??
+    (Number(process.env.HOSTED_AI_DAILY_ALERT_WORKSPACE_CALLS) || 200)
+
+  const since = new Date(Date.now() - hours * 3600_000)
+  const alerts: AiAlert[] = []
+
+  const [totalLogs, errorLogs, recentLogs, dailyCosts] = await Promise.all([
+    prisma.aiUsageLog.count({ where: { createdAt: { gte: since } } }),
+    prisma.aiUsageLog.count({ where: { createdAt: { gte: since }, success: false } }),
+    prisma.aiUsageLog.findMany({
+      where: { createdAt: { gte: since }, success: false },
+      select: {
+        workspaceId: true,
+        userId: true,
+        provider: true,
+        model: true,
+        errorMessage: true,
+        createdAt: true,
+      },
+      take: 50,
+    }),
+    prisma.aiUsageLog.findMany({
+      where: { createdAt: { gte: since }, success: true },
+      select: { createdAt: true, costUsd: true, workspaceId: true },
+    }),
+  ])
+
+  if (totalLogs === 0) return alerts
+
+  const errorRate = errorLogs / totalLogs
+  if (errorRate > errorRateThreshold && errorLogs > 5) {
+    alerts.push({
+      type: 'error_spike',
+      severity: errorRate > 0.2 ? 'critical' : 'warning',
+      message: `AI 调用错误率异常：${(errorRate * 100).toFixed(1)}%（阈值 ${(errorRateThreshold * 100).toFixed(1)}%）`,
+      metric: 'error_rate',
+      value: errorRate,
+      threshold: errorRateThreshold,
+      period: `${hours}h`,
+      count: errorLogs,
+      createdAt: new Date(),
+    })
+  }
+
+  const dailyCostMap = new Map<string, number>()
+  for (const log of dailyCosts) {
+    const date = log.createdAt.toISOString().slice(0, 10)
+    const cost = Number(log.costUsd ?? 0)
+    dailyCostMap.set(date, (dailyCostMap.get(date) ?? 0) + cost)
+  }
+  for (const [date, cost] of dailyCostMap.entries()) {
+    if (cost > dailyCostThresholdUsd) {
+      alerts.push({
+        type: 'high_cost',
+        severity: cost > dailyCostThresholdUsd * 2 ? 'critical' : 'warning',
+        message: `单日 AI 成本异常：$${cost.toFixed(2)}（阈值 $${dailyCostThresholdUsd}）`,
+        metric: 'daily_cost_usd',
+        value: cost,
+        threshold: dailyCostThresholdUsd,
+        period: date,
+        count: 1,
+        createdAt: new Date(date),
+      })
+    }
+  }
+
+  const wsDailyCalls = new Map<string, { wsId: string; date: string; count: number }>()
+  for (const log of dailyCosts) {
+    if (!log.workspaceId) continue
+    const date = log.createdAt.toISOString().slice(0, 10)
+    const key = `${log.workspaceId}:${date}`
+    const entry = wsDailyCalls.get(key) ?? { wsId: log.workspaceId, date, count: 0 }
+    entry.count += 1
+    wsDailyCalls.set(key, entry)
+  }
+  for (const { wsId, date, count } of wsDailyCalls.values()) {
+    if (count > workspaceDailyCallsThreshold) {
+      alerts.push({
+        type: 'quota_exhausted',
+        severity: 'warning',
+        message: `工作空间 ${wsId.slice(0, 8)} 单日调用 ${count} 次（阈值 ${workspaceDailyCallsThreshold}）`,
+        metric: 'workspace_daily_calls',
+        value: count,
+        threshold: workspaceDailyCallsThreshold,
+        period: date,
+        count,
+        workspaceId: wsId,
+        createdAt: new Date(date),
+      })
+    }
+  }
+
+  const providerErrors = new Map<string, number>()
+  for (const log of recentLogs) {
+    const key = log.provider || 'unknown'
+    providerErrors.set(key, (providerErrors.get(key) ?? 0) + 1)
+  }
+  for (const [provider, count] of providerErrors.entries()) {
+    if (count >= 10) {
+      alerts.push({
+        type: 'provider_failure',
+        severity: count >= 50 ? 'critical' : 'warning',
+        message: `Provider ${provider} 失败次数异常：${count} 次`,
+        metric: 'provider_errors',
+        value: count,
+        threshold: 10,
+        period: `${hours}h`,
+        count,
+        createdAt: new Date(),
+      })
+    }
+  }
+
+  return alerts.sort((a, b) => {
+    const sevOrder = { critical: 0, warning: 1 }
+    return sevOrder[a.severity] - sevOrder[b.severity] || b.createdAt.getTime() - a.createdAt.getTime()
+  })
+}
+
+export async function getAiAlertSummary(options?: AlertCheckOptions): Promise<AlertSummary> {
+  const alerts = await checkAiAlerts(options)
+  return {
+    totalAlerts: alerts.length,
+    bySeverity: {
+      warning: alerts.filter((a) => a.severity === 'warning').length,
+      critical: alerts.filter((a) => a.severity === 'critical').length,
+    },
+    byType: alerts.reduce(
+      (acc, a) => {
+        const existing = acc.find((x) => x.type === a.type)
+        if (existing) existing.count++
+        else acc.push({ type: a.type, count: 1 })
+        return acc
+      },
+      [] as Array<{ type: string; count: number }>,
+    ),
+    alerts,
+  }
+}

package/src/server/admin-ai-usage.ts

@@ -0,0 +1,134 @@
+import { prisma } from '@allbluecn/database'
+
+export interface AiUsageOverview {
+  totalCalls: number
+  totalCostUsd: number | null
+  bySource: Array<{ source: string; count: number }>
+  topWorkspaces: Array<{
+    workspaceId: string
+    workspaceName?: string
+    count: number
+    costUsd: number | null
+  }>
+  topUsers: Array<{ userId: string; userName?: string; count: number }>
+  topWorkspacesTotal: number
+  topUsersTotal: number
+  trend: Array<{ date: string; calls: number; cost: number }>
+}
+
+export interface AiUsageOverviewOptions {
+  days?: number
+  workspace?: { page?: number; perPage?: number }
+  user?: { page?: number; perPage?: number }
+}
+
+export async function getAiUsageOverview(options: AiUsageOverviewOptions = {}): Promise<AiUsageOverview> {
+  const {
+    days = 30,
+    workspace: workspaceOpt = {},
+    user: userOpt = {},
+  } = options
+  const workspacePage = workspaceOpt.page ?? 1
+  const workspacePerPage = workspaceOpt.perPage ?? 10
+  const userPage = userOpt.page ?? 1
+  const userPerPage = userOpt.perPage ?? 10
+  const since = new Date(Date.now() - days * 86400_000)
+
+  const [
+    totalCalls,
+    costAgg,
+    bySource,
+    topWorkspacesRaw,
+    topWorkspacesCount,
+    topUsersRaw,
+    topUsersCount,
+    recentLogs,
+  ] = await Promise.all([
+    prisma.aiUsageLog.count({ where: { createdAt: { gte: since } } }),
+    prisma.aiUsageLog.aggregate({
+      _sum: { costUsd: true },
+      where: { createdAt: { gte: since }, success: true },
+    }),
+    prisma.aiUsageLog.groupBy({
+      by: ['source'],
+      _count: true,
+      where: { createdAt: { gte: since } },
+    }),
+    prisma.aiUsageLog.groupBy({
+      by: ['workspaceId'],
+      _count: true,
+      _sum: { costUsd: true },
+      orderBy: { _count: { workspaceId: 'desc' } },
+      take: workspacePerPage,
+      skip: (workspacePage - 1) * workspacePerPage,
+      where: { createdAt: { gte: since } },
+    }),
+    prisma.aiUsageLog.groupBy({
+      by: ['workspaceId'],
+      _count: true,
+      where: { createdAt: { gte: since } },
+    }).then((r) => r.length),
+    prisma.aiUsageLog.groupBy({
+      by: ['userId'],
+      _count: true,
+      orderBy: { _count: { userId: 'desc' } },
+      take: userPerPage,
+      skip: (userPage - 1) * userPerPage,
+      where: { createdAt: { gte: since } },
+    }),
+    prisma.aiUsageLog.groupBy({
+      by: ['userId'],
+      _count: true,
+      where: { createdAt: { gte: since } },
+    }).then((r) => r.length),
+    prisma.aiUsageLog.findMany({
+      where: { createdAt: { gte: since } },
+      select: { createdAt: true, costUsd: true },
+    }),
+  ])
+
+  const trendMap = new Map<string, { calls: number; cost: number }>()
+  for (const log of recentLogs) {
+    const date = log.createdAt.toISOString().slice(0, 10)
+    const entry = trendMap.get(date) ?? { calls: 0, cost: 0 }
+    entry.calls += 1
+    if (log.costUsd) entry.cost += Number(log.costUsd)
+    trendMap.set(date, entry)
+  }
+  const trend = Array.from(trendMap.entries())
+    .map(([date, v]) => ({ date, ...v }))
+    .sort((a, b) => a.date.localeCompare(b.date))
+
+  const workspaceIds = topWorkspacesRaw.map((w) => w.workspaceId)
+  const userIds = topUsersRaw.map((u) => u.userId)
+  const [workspaces, users] = await Promise.all([
+    workspaceIds.length > 0
+      ? prisma.workspace.findMany({ where: { id: { in: workspaceIds } }, select: { id: true, name: true } })
+      : [],
+    userIds.length > 0
+      ? prisma.user.findMany({ where: { id: { in: userIds } }, select: { id: true, username: true } })
+      : [],
+  ])
+  const wsNameMap = new Map(workspaces.map((w) => [w.id, w.name]))
+  const userNameMap = new Map(users.map((u) => [u.id, u.username]))
+
+  return {
+    totalCalls,
+    totalCostUsd: costAgg._sum.costUsd ? Number(costAgg._sum.costUsd) : null,
+    bySource: bySource.map((b) => ({ source: b.source, count: b._count })),
+    topWorkspaces: topWorkspacesRaw.map((w) => ({
+      workspaceId: w.workspaceId,
+      workspaceName: wsNameMap.get(w.workspaceId),
+      count: w._count,
+      costUsd: w._sum.costUsd ? Number(w._sum.costUsd) : null,
+    })),
+    topUsers: topUsersRaw.map((u) => ({
+      userId: u.userId,
+      userName: userNameMap.get(u.userId),
+      count: u._count,
+    })),
+    topWorkspacesTotal: topWorkspacesCount,
+    topUsersTotal: topUsersCount,
+    trend,
+  }
+}

package/src/server/auth-helpers.ts

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import { getRequest } from '@tanstack/react-start/server'
+import { getCurrentSession, type Session } from '@/lib/session'
+
+export class UnauthorizedError extends Error {
+  constructor(message: string = 'UNAUTHORIZED') {
+    super(message)
+    this.name = 'UnauthorizedError'
+    Object.setPrototypeOf(this, UnauthorizedError.prototype)
+  }
+}
+
+export class ForbiddenError extends Error {
+  constructor(message: string = 'FORBIDDEN') {
+    super(message)
+    this.name = 'ForbiddenError'
+    Object.setPrototypeOf(this, ForbiddenError.prototype)
+  }
+}
+
+export async function requireAdmin(): Promise<Session> {
+  const request = getRequest()
+  const session = await getCurrentSession(request)
+  if (!session?.user?.id) {
+    const url = request?.url ?? 'unknown'
+    console.warn(`[requireAdmin] 未授权访问: ${url}`)
+    throw new UnauthorizedError()
+  }
+  if (session.user.role !== 'ADMIN' && session.user.role !== 'SUPER_ADMIN') {
+    const url = request?.url ?? 'unknown'
+    console.warn(`[requireAdmin] 权限不足 (role=${session.user.role ?? 'null'}): ${url}`)
+    throw new ForbiddenError()
+  }
+  return session
+}

package/src/server/entitlements.ts

@@ -0,0 +1,24 @@
+import { FeatureRegistry } from '@allbluecn/kernel'
+
+export class FeatureUnavailableError extends Error {
+  constructor(feature: string) {
+    super(`功能 ${feature} 在当前部署不可用`)
+    this.name = 'FeatureUnavailableError'
+    Object.setPrototypeOf(this, FeatureUnavailableError.prototype)
+  }
+}
+
+export class FeatureForbiddenError extends Error {
+  constructor(feature: string) {
+    super(`无权限使用功能 ${feature}`)
+    this.name = 'FeatureForbiddenError'
+    Object.setPrototypeOf(this, FeatureForbiddenError.prototype)
+  }
+}
+
+export async function requireFeature(_request: Request | undefined, feature: string): Promise<void> {
+  const meta = FeatureRegistry[feature as keyof typeof FeatureRegistry]
+  if (meta?.tier === 'oss') return
+  void _request
+  return
+}

package/src/server/knowledge-public/canonical-id.ts

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+export function legalCanonicalId(input: { title: string; code?: string }): string {
+  const code = input.code?.trim()
+  return code || input.title.trim()
+}
+
+export function complianceCanonicalId(input: { title: string; code?: string }): string {
+  const code = input.code?.trim()
+  return code || input.title.trim()
+}
+
+export function bookmarkCanonicalId(rawUrl: string): string {
+  let url: URL
+  try {
+    url = new URL(rawUrl.trim())
+  } catch {
+    return rawUrl.trim().toLowerCase()
+  }
+  const host = url.hostname.toLowerCase().replace(/^www\./, '')
+  let path = url.pathname.replace(/\/+$/, '')
+  if (path.endsWith('.git')) path = path.replace(/\.git$/, '')
+  return path ? `${host}${path}` : host
+}
+
+export function parseGithubUrl(rawUrl: string): { owner: string; repo: string } | null {
+  let url: URL
+  try {
+    url = new URL(rawUrl.trim())
+  } catch {
+    return null
+  }
+  if (url.hostname.toLowerCase() !== 'github.com') return null
+  const parts = url.pathname.split('/').filter(Boolean)
+  if (parts.length < 2) return null
+  const owner = parts[0]
+  const repo = parts[1].replace(/\.git$/, '')
+  if (!owner || !repo) return null
+  return { owner, repo }
+}