Fix .gitignore excluding frontend/src/lib and add missing TS modules

.gitignore

@@ -8,7 +8,7 @@ dist/
 downloads/
 eggs/
 .eggs/
-lib/
+# lib/
 lib64/
 parts/
 sdist/

frontend/src/lib/api.ts

@@ -0,0 +1,139 @@
+import axios, { AxiosError, type AxiosRequestConfig } from 'axios'
+
+export type ApiError = {
+  status: number
+  message: string
+  data?: unknown
+}
+
+export type ApiResponse<T> = {
+  code: number
+  msg: string
+  data?: T | null
+}
+
+const defaultBaseUrl = 'http://localhost:8000/api/v1'
+const baseURL = import.meta.env.VITE_API_BASE_URL || defaultBaseUrl
+
+export const http = axios.create({
+  baseURL,
+  timeout: 30000,
+})
+
+function normalizePath(path: string) {
+  if (path.startsWith('http://') || path.startsWith('https://')) return path
+  return path.replace(/^\/+/, '')
+}
+
+function extractWrappedErrorMessage(data: unknown) {
+  if (!data || typeof data !== 'object') return undefined
+  const obj = data as Record<string, unknown>
+  const msg = obj.msg
+  const code = obj.code
+  if (typeof msg === 'string' && typeof code === 'number') return `API ${code}: ${msg}`
+  if (typeof msg === 'string') return msg
+  return undefined
+}
+
+function toApiError(error: unknown): ApiError {
+  if (axios.isAxiosError(error)) {
+    const axiosError = error as AxiosError
+    const status = axiosError.response?.status ?? 0
+    const wrappedMsg = extractWrappedErrorMessage(axiosError.response?.data)
+    const message =
+      wrappedMsg ||
+      (typeof axiosError.response?.data === 'string'
+        ? axiosError.response.data
+        : axiosError.message)
+
+    return {
+      status,
+      message,
+      data: axiosError.response?.data,
+    }
+  }
+
+  return {
+    status: 0,
+    message: error instanceof Error ? error.message : String(error),
+  }
+}
+
+export async function apiGet<T>(path: string, config?: AxiosRequestConfig) {
+  try {
+    const res = await http.get<T>(normalizePath(path), config)
+    return res.data
+  } catch (error) {
+    throw toApiError(error)
+  }
+}
+
+export function unwrapApiResponse<T>(value: unknown) {
+  if (!value || typeof value !== 'object') return { ok: false as const, error: '响应不是对象' }
+  const obj = value as Record<string, unknown>
+  if (typeof obj.code !== 'number' || typeof obj.msg !== 'string') {
+    return { ok: false as const, error: '响应缺少 code/msg 字段' }
+  }
+  const code = obj.code
+  const msg = obj.msg
+  const data = obj.data as T | null | undefined
+  if (code !== 200) {
+    return { ok: false as const, error: `API ${code}: ${msg}`, code, msg, data }
+  }
+  return { ok: true as const, data }
+}
+
+export async function apiGetWrapped<T>(path: string, config?: AxiosRequestConfig) {
+  const raw = await apiGet<unknown>(path, config)
+  const parsed = unwrapApiResponse<T>(raw)
+  if (parsed.ok) return parsed.data as T
+  if (parsed.error === '响应缺少 code/msg 字段') return raw as T
+  const apiError: ApiError = {
+    status: 0,
+    message: parsed.error,
+    data: raw,
+  }
+  throw apiError
+}
+
+export async function apiPost<TRes, TReq>(
+  path: string,
+  data: TReq,
+  config?: AxiosRequestConfig,
+) {
+  try {
+    const res = await http.post<TRes>(normalizePath(path), data, config)
+    return res.data
+  } catch (error) {
+    throw toApiError(error)
+  }
+}
+
+export async function apiPostWrapped<TRes, TReq>(
+  path: string,
+  data: TReq,
+  config?: AxiosRequestConfig,
+) {
+  const raw = await apiPost<unknown, TReq>(path, data, config)
+  const parsed = unwrapApiResponse<TRes>(raw)
+  if (parsed.ok) return parsed.data as TRes
+  if (parsed.error === '响应缺少 code/msg 字段') return raw as TRes
+  const apiError: ApiError = {
+    status: 0,
+    message: parsed.error,
+    data: raw,
+  }
+  throw apiError
+}
+
+export async function apiGetText(path: string, config?: AxiosRequestConfig) {
+  try {
+    const res = await http.get<string>(normalizePath(path), {
+      ...config,
+      responseType: 'text',
+    })
+    return res.data
+  } catch (error) {
+    throw toApiError(error)
+  }
+}

frontend/src/lib/business.ts

@@ -0,0 +1,53 @@
+import { apiGetWrapped } from './api'
+
+export type GeneratedPostRecord = {
+  id: number
+  material_id: number | null
+  prompt_id: number | null
+  content: string | null
+  status: string | null
+  created_at: string | null
+  compliance_status: string | null
+  medical_risk_level: string | null
+  review_status: string | null
+  hit_words: string | null
+}
+
+export type GeneratedPostListResponse = {
+  posts: GeneratedPostRecord[]
+  total: number
+  limit: number
+  offset: number
+}
+
+export type LeadRecord = {
+  id: number
+  interaction_id: number | null
+  contact_info: string | null
+  status: string | null
+  created_at: string | null
+  last_sync_at: string | null
+}
+
+export type LeadListResponse = {
+  leads: LeadRecord[]
+  total: number
+  limit: number
+  offset: number
+}
+
+export async function listGeneratedPosts(params: { limit: number; offset: number; status?: string }) {
+  const search = new URLSearchParams()
+  search.set('limit', String(params.limit))
+  search.set('offset', String(params.offset))
+  if (params.status) search.set('status', params.status)
+  return apiGetWrapped<GeneratedPostListResponse>(`business/posts?${search.toString()}`)
+}
+
+export async function listLeads(params: { limit: number; offset: number; status?: string }) {
+  const search = new URLSearchParams()
+  search.set('limit', String(params.limit))
+  search.set('offset', String(params.offset))
+  if (params.status) search.set('status', params.status)
+  return apiGetWrapped<LeadListResponse>(`business/leads?${search.toString()}`)
+}

frontend/src/lib/content.ts

@@ -0,0 +1,69 @@
+import type { ApiError } from './api'
+import { apiGetWrapped } from './api'
+
+export type RawNoteRecord = {
+  id: number
+  source_platform: string | null
+  content: string | null
+  author: string | null
+  url: string | null
+  created_at: string | null
+}
+
+export type RawNoteListResponse = {
+  notes: RawNoteRecord[]
+  total: number
+  limit: number
+  offset: number
+  query: string | null
+}
+
+export type CleanedNoteRecord = {
+  id: number
+  raw_note_id: number | null
+  cleaned_content: string | null
+  created_at: string | null
+  raw_author: string | null
+  raw_url: string | null
+}
+
+export type CleanedNoteListResponse = {
+  notes: CleanedNoteRecord[]
+  total: number
+  limit: number
+  offset: number
+  query: string | null
+}
+
+export type ListContentParams = {
+  limit: number
+  offset: number
+  query?: string
+}
+
+function buildSearch(params: ListContentParams) {
+  const search = new URLSearchParams()
+  search.set('limit', String(params.limit))
+  search.set('offset', String(params.offset))
+  const q = String(params.query || '').trim()
+  if (q) search.set('query', q)
+  return search.toString()
+}
+
+export async function listRawNotes(params: ListContentParams) {
+  return apiGetWrapped<RawNoteListResponse>(`content/raw-notes?${buildSearch(params)}`)
+}
+
+export async function listCleanedNotes(params: ListContentParams) {
+  return apiGetWrapped<CleanedNoteListResponse>(`content/cleaned-notes?${buildSearch(params)}`)
+}
+
+export function isOrchestratorDbUnavailable(error: ApiError | null | undefined) {
+  if (!error) return false
+  if (error.status !== 503) return false
+  if (typeof error.message === 'string' && error.message.toLowerCase().includes('orchestrator db')) return true
+  const data = error.data
+  if (!data || typeof data !== 'object') return false
+  const obj = data as Record<string, unknown>
+  return obj.code === 10010 || obj.msg === 'orchestrator db unavailable'
+}

frontend/src/lib/errors.ts

@@ -0,0 +1,42 @@
+import { apiGetWrapped } from './api'
+import type { TaskRecord } from './tasks'
+
+export type ErrorSummaryResponse = {
+  scan_limit: number
+  scanned: number
+  error_kind_counts: Record<string, number>
+  tasks: TaskRecord[]
+  total: number
+  limit: number
+  offset: number
+}
+
+export type ErrorSummaryParams = {
+  scan_limit?: number
+  limit: number
+  offset: number
+  status?: string[]
+  error_kind?: string[]
+}
+
+function join(values?: string[]) {
+  const parts = (values || []).map((v) => String(v).trim()).filter((v) => v !== '')
+  return parts.length ? parts.join(',') : undefined
+}
+
+export async function getErrorSummary(params: ErrorSummaryParams) {
+  const search = new URLSearchParams()
+  search.set('limit', String(params.limit))
+  search.set('offset', String(params.offset))
+
+  if (typeof params.scan_limit === 'number' && Number.isFinite(params.scan_limit) && params.scan_limit > 0) {
+    search.set('scan_limit', String(Math.floor(params.scan_limit)))
+  }
+
+  const status = join(params.status)
+  const errorKind = join(params.error_kind)
+  if (status) search.set('status', status)
+  if (errorKind) search.set('error_kind', errorKind)
+
+  return apiGetWrapped<ErrorSummaryResponse>(`errors/summary?${search.toString()}`)
+}

frontend/src/lib/polling.ts

@@ -0,0 +1,39 @@
+export type PollOptions<T> = {
+  intervalMs: number
+  immediate?: boolean
+  shouldStop?: (value: T) => boolean
+  signal?: AbortSignal
+}
+
+function sleep(ms: number, signal?: AbortSignal) {
+  if (ms <= 0) return Promise.resolve()
+  return new Promise<void>((resolve, reject) => {
+    const timer = window.setTimeout(() => {
+      signal?.removeEventListener('abort', onAbort)
+      resolve()
+    }, ms)
+
+    function onAbort() {
+      window.clearTimeout(timer)
+      reject(new DOMException('Aborted', 'AbortError'))
+    }
+
+    if (signal) {
+      if (signal.aborted) return onAbort()
+      signal.addEventListener('abort', onAbort, { once: true })
+    }
+  })
+}
+
+export async function poll<T>(fn: () => Promise<T>, options: PollOptions<T>) {
+  const { intervalMs, immediate = true, shouldStop, signal } = options
+
+  if (!immediate) await sleep(intervalMs, signal)
+
+  while (true) {
+    if (signal?.aborted) throw new DOMException('Aborted', 'AbortError')
+    const value = await fn()
+    if (shouldStop?.(value)) return value
+    await sleep(intervalMs, signal)
+  }
+}

frontend/src/lib/resources.ts

@@ -0,0 +1,72 @@
+import { apiGetWrapped, apiPostWrapped } from './api'
+
+export type AccountSnapshotItem = {
+  id: string
+  tags: string[]
+  risk_score: number
+  enabled: boolean
+  available: boolean
+  cooldown_remaining_s: number
+  cooldown_until: string | null
+  last_error_kind: string | null
+  last_error_at: string | null
+}
+
+export type AccountPoolSnapshotResponse = {
+  now: string
+  accounts: AccountSnapshotItem[]
+  seed: number
+}
+
+export type SessionLightReport = {
+  id: string
+  account_id: string | null
+  has_cookie: boolean
+  has_storage_state: boolean
+  cookie_ok: boolean
+  storage_state_ok: boolean
+  cookie_reason: string | null
+  storage_state_reason: string | null
+  checked_at: string
+}
+
+export type SessionPoolLightCheckResponse = {
+  now: string
+  sessions: SessionLightReport[]
+}
+
+export type ProxyPoolSnapshotResponse = {
+  available_count: number
+  avg_score: number
+  ejected_total: number
+  failures_total_by_reason: Record<string, number>
+  recent_failures_by_reason: Record<string, number>
+  last_fail_reasons_by_reason: Record<string, number>
+}
+
+export async function getResourceAccounts() {
+  return apiGetWrapped<AccountPoolSnapshotResponse>('resources/accounts')
+}
+
+export async function getResourceSessions() {
+  return apiGetWrapped<SessionPoolLightCheckResponse>('resources/sessions')
+}
+
+export async function getResourceProxies() {
+  return apiGetWrapped<ProxyPoolSnapshotResponse>('resources/proxies')
+}
+
+export async function cooldownAccount(accountId: string, seconds: number) {
+  return apiPostWrapped<{ account_id: string, cooldown_seconds: number }, { seconds: number }>(
+    `resources/accounts/${encodeURIComponent(accountId)}/cooldown`,
+    { seconds }
+  )
+}
+
+export async function disableAccount(accountId: string) {
+  return apiPostWrapped<{ account_id: string, disabled: boolean }, {}>(
+    `resources/accounts/${encodeURIComponent(accountId)}/disable`,
+    {}
+  )
+}
+

frontend/src/lib/tasks.ts

@@ -0,0 +1,193 @@
+import axios from 'axios'
+import type { ApiError } from './api'
+import { apiGetWrapped, apiPostWrapped, http, unwrapApiResponse } from './api'
+
+export type TaskStatus =
+  | 'queued'
+  | 'running'
+  | 'retrying'
+  | 'fallback_running'
+  | 'waiting_rpa'
+  | 'rpa_running'
+  | 'rpa_imported'
+  | 'rpa_failed'
+  | 'risk_paused'
+  | 'succeeded'
+  | 'failed'
+
+export type TaskError = {
+  kind?: string
+  message?: string
+  [key: string]: unknown
+}
+
+export type TaskRecord = {
+  id: string
+  status: TaskStatus
+  task_type: string
+  target: string
+  payload: Record<string, unknown>
+  engine?: string | null
+  callback?: unknown
+  created: number
+  started?: number | null
+  finished?: number | null
+  retry_count: number
+  error?: TaskError | null
+}
+
+export type TaskListResponse = {
+  tasks: TaskRecord[]
+  total: number
+  limit: number
+  offset: number
+}
+
+export type TaskStatusResponse = {
+  task: TaskRecord
+}
+
+export type TaskCreateRequest = {
+  task_type: string
+  target?: string | null
+  engine?: string | null
+  payload?: Record<string, unknown>
+}
+
+export type TaskCreateResponse = {
+  task: TaskRecord
+}
+
+export type TaskResultResponse = {
+  task_id: string
+  status: TaskStatus
+  raw: unknown | null
+  normalized: unknown | null
+  meta: Record<string, unknown>
+}
+
+export type ListTasksParams = {
+  limit: number
+  offset: number
+  status?: string[]
+  task_type?: string[]
+  engine?: string[]
+  error_kind?: string[]
+  sort?: string
+}
+
+function normalizePath(path: string) {
+  return path.replace(/^\/+/, '')
+}
+
+function toApiError(error: unknown): ApiError {
+  if (axios.isAxiosError(error)) {
+    if (!error.response) {
+      return { status: 0, message: error.message }
+    }
+    const status = error.response?.status ?? 0
+    const body = error.response?.data
+    const wrapped = unwrapApiResponse<unknown>(body)
+    const message =
+      wrapped.ok || wrapped.error === '响应缺少 code/msg 字段'
+        ? error.message
+        : wrapped.error
+    return { status, message, data: body }
+  }
+
+  return {
+    status: 0,
+    message: error instanceof Error ? error.message : String(error),
+  }
+}
+
+function join(values?: string[]) {
+  const parts = (values || []).map((v) => String(v).trim()).filter((v) => v !== '')
+  return parts.length ? parts.join(',') : undefined
+}
+
+export async function listTasks(params: ListTasksParams) {
+  const search = new URLSearchParams()
+  search.set('limit', String(params.limit))
+  search.set('offset', String(params.offset))
+  const status = join(params.status)
+  const taskType = join(params.task_type)
+  const engine = join(params.engine)
+  const errorKind = join(params.error_kind)
+  const sort = String(params.sort || '').trim()
+
+  if (status) search.set('status', status)
+  if (taskType) search.set('task_type', taskType)
+  if (engine) search.set('engine', engine)
+  if (errorKind) search.set('error_kind', errorKind)
+  if (sort) search.set('sort', sort)
+
+  return apiGetWrapped<TaskListResponse>(`tasks?${search.toString()}`)
+}
+
+export async function createTask(payload: TaskCreateRequest) {
+  const res = await apiPostWrapped<TaskCreateResponse, TaskCreateRequest>('tasks', payload)
+  return res.task
+}
+
+export async function retryTask(taskId: string) {
+  const res = await apiPostWrapped<TaskStatusResponse, {}>(`tasks/${encodeURIComponent(taskId)}/retry`, {})
+  return res.task
+}
+
+export async function cancelTask(taskId: string) {
+  const res = await apiPostWrapped<TaskStatusResponse, {}>(`tasks/${encodeURIComponent(taskId)}/cancel`, {})
+  return res.task
+}
+
+export async function markTaskRpa(taskId: string) {
+  const res = await apiPostWrapped<TaskStatusResponse, {}>(`tasks/${encodeURIComponent(taskId)}/mark-rpa`, {})
+  return res.task
+}
+
+export async function getTask(taskId: string) {
+  const res = await apiGetWrapped<TaskStatusResponse>(`tasks/${encodeURIComponent(taskId)}`)
+  return res.task
+}
+
+export async function getTaskResult(taskId: string, signal?: AbortSignal) {
+  try {
+    const res = await http.get<unknown>(normalizePath(`tasks/${encodeURIComponent(taskId)}/result`), {
+      validateStatus: () => true,
+      signal,
+    })
+    if (res.status === 409) return { ready: false as const, body: res.data }
+    if (res.status !== 200) {
+      const wrapped = unwrapApiResponse<unknown>(res.data)
+      const message =
+        wrapped.ok || wrapped.error === '响应缺少 code/msg 字段'
+          ? `HTTP ${res.status}`
+          : wrapped.error
+      const apiError: ApiError = { status: res.status, message, data: res.data }
+      throw apiError
+    }
+
+    const wrapped = unwrapApiResponse<TaskResultResponse>(res.data)
+    if (!wrapped.ok) {
+      const apiError: ApiError = { status: res.status, message: wrapped.error, data: res.data }
+      throw apiError
+    }
+
+    return { ready: true as const, data: wrapped.data ?? null }
+  } catch (e) {
+    if (axios.isAxiosError(e) && e.code === 'ERR_CANCELED') {
+      throw new DOMException('Aborted', 'AbortError')
+    }
+    if (
+      !!e &&
+      typeof e === 'object' &&
+      'status' in e &&
+      typeof (e as { status: unknown }).status === 'number' &&
+      'message' in e &&
+      typeof (e as { message: unknown }).message === 'string'
+    ) {
+      throw e as ApiError
+    }
+    throw toApiError(e)
+  }
+}