@blynkai/cli 0.1.1

package/src/search/normalize-payload.mjs

@@ -0,0 +1,201 @@
+import { ErrorCode } from '../core/errors.mjs'
+import { fail } from '../core/response.mjs'
+
+export const SEARCH_SCENE_CONFIG = {
+  'data-center': {
+    upstreamPath: '/v1/article/search',
+    timeKind: 'publish',
+    defaultSortField: 'publish_time',
+  },
+  'warning-center': {
+    upstreamPath: '/v1/index',
+    timeKind: 'push',
+    defaultSortField: 'push_time',
+  },
+  'website-stats': {
+    upstreamPath: '/v1/article/website',
+    timeKind: 'auto',
+    defaultSortField: 'publish_time',
+  },
+}
+
+function normalizeCenter(value, scene) {
+  if (value === 'warning' || scene === 'warning-center') return 'warning'
+  return 'data'
+}
+
+function resolveSearchConfig(body) {
+  const center = normalizeCenter(body.center, body.scene)
+  const stats = body.output?.website_stats || body.output?.stats === 'website' ? 'website' : ''
+  const scene =
+    stats === 'website' ? 'website-stats' : center === 'warning' ? 'warning-center' : 'data-center'
+
+  return {
+    center,
+    stats,
+    scene,
+    config: {
+      ...SEARCH_SCENE_CONFIG[scene],
+      timeKind: center === 'warning' ? 'push' : 'publish',
+      defaultSortField: center === 'warning' ? 'push_time' : 'publish_time',
+    },
+  }
+}
+
+function isPresent(value) {
+  if (value === undefined || value === null) return false
+  if (Array.isArray(value)) return value.length > 0
+  if (typeof value === 'string') return value.trim() !== ''
+  return true
+}
+
+function cleanObject(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, item]) => {
+      if (item === undefined) return false
+      if (Array.isArray(item)) return item.length > 0
+      return true
+    }),
+  )
+}
+
+function formatDateTime(date) {
+  const pad = (value) => String(value).padStart(2, '0')
+  return [
+    date.getFullYear(),
+    pad(date.getMonth() + 1),
+    pad(date.getDate()),
+  ].join('-')
+    + 'T'
+    + [pad(date.getHours()), pad(date.getMinutes()), pad(date.getSeconds())].join(':')
+}
+
+function normalizeDateTime(value) {
+  if (!isPresent(value)) return ''
+  if (typeof value !== 'string') return String(value)
+  const trimmed = value.trim()
+  if (!trimmed) return ''
+
+  const noTimezone = trimmed.replace(/Z$/, '').replace(/[+-]\d{2}:\d{2}$/, '')
+  const normalized = noTimezone.replace(/\.\d+$/, '')
+  if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/.test(normalized)) return normalized
+
+  const parsed = new Date(trimmed)
+  if (Number.isNaN(parsed.getTime())) return normalized
+  return formatDateTime(parsed)
+}
+
+function defaultTimeRange() {
+  const end = new Date()
+  const start = new Date(end.getTime() - 24 * 60 * 60 * 1000)
+  return {
+    start: formatDateTime(start),
+    end: formatDateTime(end),
+  }
+}
+
+function resolveTimeKind(scene, body) {
+  const config = SEARCH_SCENE_CONFIG[scene]
+  if (!config) return 'publish'
+  if (config.timeKind !== 'auto') return config.timeKind
+
+  if (isPresent(body.time?.push_start) || isPresent(body.time?.push_end)) return 'push'
+  return 'publish'
+}
+
+export function normalizeSearchPayload(body) {
+  const { center, stats, scene, config } = resolveSearchConfig(body)
+  if (!config) {
+    return {
+      error: fail(ErrorCode.INVALID_PARAMS, {
+        field: 'center',
+        supported: ['data', 'warning'],
+      }),
+    }
+  }
+
+  const timeKind = config.timeKind || resolveTimeKind(scene, body)
+  const time = body.time ?? {}
+  const query = body.query ?? {}
+  const filters = body.filters ?? {}
+  const page = body.page ?? {}
+  const sort = body.sort ?? {}
+  const fallbackTime = defaultTimeRange()
+  const keywords = query.keywords ?? ''
+  const hasKeywords = typeof keywords === 'string' && keywords.trim() !== ''
+  const searchMode = query.search_mode ?? 'keyword'
+  const defaultSortField =
+    searchMode === 'keyword' && hasKeywords ? '_score' : config.defaultSortField
+
+  const publishStart =
+    timeKind === 'publish'
+      ? normalizeDateTime(time.publish_start || time.start || fallbackTime.start)
+      : normalizeDateTime(time.publish_start || '')
+  const publishEnd =
+    timeKind === 'publish'
+      ? normalizeDateTime(time.publish_end || time.end || fallbackTime.end)
+      : normalizeDateTime(time.publish_end || '')
+  const pushStart =
+    timeKind === 'push'
+      ? normalizeDateTime(time.push_start || time.start || fallbackTime.start)
+      : normalizeDateTime(time.push_start || '')
+  const pushEnd =
+    timeKind === 'push'
+      ? normalizeDateTime(time.push_end || time.end || fallbackTime.end)
+      : normalizeDateTime(time.push_end || '')
+
+  const payload = cleanObject({
+    publish_time_start: publishStart,
+    publish_time_end: publishEnd,
+    push_time_start: pushStart,
+    push_time_end: pushEnd,
+    keywords,
+    article_categories: filters.article_categories ?? [],
+    media_channels: filters.media_channels ?? [],
+    website_names: filters.website_names ?? [],
+    sentiment: filters.sentiment ?? [],
+    risk_levels: filters.risk_levels ?? [],
+    media_tags: filters.media_tags ?? [],
+    search_fields: query.search_fields ?? [],
+    article_type: filters.article_type ?? [],
+    article_id_list: filters.article_id_list ?? [],
+    article_status: filters.article_status ?? '',
+    status: filters.status ?? '',
+    is_valid:
+      center === 'warning'
+        ? filters.is_valid ?? ''
+        : filters.is_valid === undefined
+          ? 'Valid'
+          : filters.is_valid,
+    third_party: filters.third_party ?? [],
+    third_party_id: filters.third_party_id ?? null,
+    sort_field: sort.field ?? defaultSortField,
+    sort_order: sort.order ?? 'desc',
+    keywords_must_include: query.keywords_must_include ?? [],
+    keywords_should_include: query.keywords_should_include ?? [],
+    keywords_must_exclude: query.keywords_must_exclude ?? [],
+    page: page.page ?? 1,
+    size: page.size ?? 10,
+    search_mode: searchMode,
+    semantic_query: query.semantic_query ?? null,
+    semantic_top_n: query.semantic_top_n ?? null,
+    collapse_field: filters.collapse_field ?? '',
+    review_status:
+      center === 'warning' ? filters.review_status ?? 'pushed' : filters.review_status ?? null,
+    reviewer: filters.reviewer ?? null,
+    is_similar_collapse: Boolean(filters.is_similar_collapse),
+    topic_id: filters.topic_id,
+    warning_cluster_id: filters.warning_cluster_id,
+    exclude_ids: filters.exclude_ids ?? [],
+  })
+
+  return {
+    scene,
+    center,
+    stats,
+    upstreamPath: config.upstreamPath,
+    timeKind,
+    payload,
+    dryRun: Boolean(body.output?.dry_run),
+  }
+}

package/src/server/index.mjs

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+
+import { createServer } from 'node:http'
+import { mkdir, writeFile } from 'node:fs/promises'
+import { resolveUpstreamBaseUrl } from '../core/config.mjs'
+import { ErrorCode } from '../core/errors.mjs'
+import { fail, ok, sendJson } from '../core/response.mjs'
+import { logFile, pidFile, runtimeDir } from '../core/runtime-paths.mjs'
+import { getSessionState, revokeSession, syncBrowserSession } from '../core/session-store.mjs'
+import { availableCommands } from '../data/commands.mjs'
+import { normalizeSearchPayload } from '../search/normalize-payload.mjs'
+
+const host = '127.0.0.1'
+const preferredPort = Number(process.env.LINGRUI_AGENT_PORT ?? 38100)
+let activePort = preferredPort
+const upstreamBaseUrl = resolveUpstreamBaseUrl()
+const upstreamTimeoutMs = Number(process.env.LINGRUI_UPSTREAM_TIMEOUT_MS ?? 15000)
+
+function isLoopback(req) {
+  const address = req.socket.remoteAddress
+  return address === '127.0.0.1' || address === '::1' || address === '::ffff:127.0.0.1'
+}
+
+async function requireActiveSession() {
+  const { state, session } = await getSessionState()
+  if (state === 'active') return { authorized: true, session }
+  if (state === 'revoked') return { authorized: false, code: ErrorCode.SESSION_REVOKED }
+  if (state === 'expired') return { authorized: false, code: ErrorCode.SESSION_EXPIRED }
+  return { authorized: false, code: ErrorCode.AUTH_REQUIRED }
+}
+
+async function readJson(req) {
+  const chunks = []
+  for await (const chunk of req) {
+    chunks.push(chunk)
+  }
+
+  if (!chunks.length) return {}
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString('utf8'))
+  } catch {
+    return null
+  }
+}
+
+async function callUpstream(path, payload, auth) {
+  if (!upstreamBaseUrl) {
+    return {
+      proxied: false,
+      reason: 'LINGRUI_UPSTREAM_BASE_URL_not_configured',
+    }
+  }
+
+  const token = auth.session?.token?.value
+  if (!token) {
+    return {
+      proxied: false,
+      reason: 'browser_token_not_available_in_memory',
+    }
+  }
+
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort(), upstreamTimeoutMs)
+
+  try {
+    const response = await fetch(`${upstreamBaseUrl}${path}`, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        Authorization: `bearer ${token}`,
+      },
+      signal: controller.signal,
+      body: JSON.stringify(payload),
+    })
+
+    const data = await response.json()
+    return {
+      proxied: true,
+      status: response.status,
+      data,
+    }
+  } catch (error) {
+    const causeMessage =
+      error && typeof error === 'object' && 'cause' in error && error.cause instanceof Error
+        ? error.cause.message
+        : ''
+    return {
+      proxied: false,
+      reason: error?.name === 'AbortError' ? 'upstream_request_timeout' : 'upstream_request_failed',
+      message: error instanceof Error ? error.message : String(error),
+      ...(causeMessage ? { cause: causeMessage } : {}),
+    }
+  } finally {
+    clearTimeout(timeout)
+  }
+}
+
+async function route(req, res) {
+  if (req.method === 'OPTIONS') {
+    return sendJson(res, 200, ok())
+  }
+
+  if (!isLoopback(req)) {
+    return sendJson(res, 403, fail(ErrorCode.LOOPBACK_ONLY))
+  }
+
+  const url = new URL(req.url ?? '/', `http://${host}:${activePort}`)
+  const key = `${req.method} ${url.pathname}`
+
+  try {
+    if (key === 'GET /health') {
+      const { state } = await getSessionState()
+      return sendJson(
+        res,
+        200,
+        ok({
+          service: 'lingrui-local-agent',
+          status: 'online',
+          authState: state,
+          version: '0.1.0',
+          port: activePort,
+          upstreamConfigured: Boolean(upstreamBaseUrl),
+          upstreamBaseUrl: upstreamBaseUrl || null,
+        }),
+      )
+    }
+
+    if (key === 'GET /status') {
+      const { state, session } = await getSessionState()
+      return sendJson(
+        res,
+        200,
+        ok({
+          service: 'lingrui-cli',
+          status: 'online',
+          loggedIn: state === 'active',
+          authState: state,
+          user: state === 'active' ? session?.user ?? null : null,
+          port: activePort,
+        }),
+      )
+    }
+
+    if (key === 'POST /auth/sync' || key === 'POST /auth/reconnect') {
+      const payload = await readJson(req)
+      if (!payload) {
+        return sendJson(res, 400, fail(ErrorCode.INVALID_PARAMS, { field: 'body' }))
+      }
+      if (!payload?.token) {
+        return sendJson(res, 400, fail(ErrorCode.INVALID_PARAMS, { field: 'token' }))
+      }
+
+      const session = await syncBrowserSession(payload)
+      return sendJson(
+        res,
+        200,
+        ok({
+          sessionId: session.sessionId,
+          expiresAt: session.expiresAt,
+          user: session.user,
+          scopes: session.scopes,
+        }),
+      )
+    }
+
+    if (key === 'GET /auth/whoami') {
+      const auth = await requireActiveSession()
+      if (!auth.authorized) return sendJson(res, 401, fail(auth.code))
+      return sendJson(
+        res,
+        200,
+        ok({
+          user: auth.session.user,
+          scopes: auth.session.scopes,
+          expiresAt: auth.session.expiresAt,
+        }),
+      )
+    }
+
+    if (key === 'GET /commands/list') {
+      const auth = await requireActiveSession()
+      if (!auth.authorized) return sendJson(res, 401, fail(auth.code))
+      return sendJson(
+        res,
+        200,
+        ok({
+          items: availableCommands,
+          total: availableCommands.length,
+        }),
+      )
+    }
+
+    if (key === 'POST /auth/logout') {
+      await revokeSession()
+      console.log('[auth] browser signed out, local session revoked')
+      return sendJson(res, 200, ok({ status: 'revoked' }))
+    }
+
+    if (key === 'POST /skills/check') {
+      const auth = await requireActiveSession()
+      if (!auth.authorized) return sendJson(res, 401, fail(auth.code))
+      return sendJson(
+        res,
+        200,
+        ok({
+          allowed: true,
+          status: 'logged_in',
+          user: auth.session.user,
+        }),
+      )
+    }
+
+    if (key === 'POST /api/search') {
+      const auth = await requireActiveSession()
+      if (!auth.authorized) return sendJson(res, 401, fail(auth.code))
+
+      const body = await readJson(req)
+      const normalized = normalizeSearchPayload(body)
+      if (normalized.error) return sendJson(res, 400, normalized.error)
+
+      if (!normalized.dryRun) {
+        const upstream = await callUpstream(normalized.upstreamPath, normalized.payload, auth)
+        if (upstream.proxied) {
+          return sendJson(
+            res,
+            200,
+            ok({
+              scene: normalized.scene,
+              center: normalized.center,
+              stats: normalized.stats,
+              upstream_path: normalized.upstreamPath,
+              upstream_status: upstream.status,
+              result: upstream.data,
+            }),
+          )
+        }
+
+        return sendJson(
+          res,
+          200,
+          ok({
+            scene: normalized.scene,
+            center: normalized.center,
+            stats: normalized.stats,
+            upstream_path: normalized.upstreamPath,
+            proxied: false,
+            reason: upstream.reason,
+            ...(upstream.status ? { upstream_status: upstream.status } : {}),
+            ...(upstream.message ? { message: upstream.message } : {}),
+            ...(upstream.cause ? { cause: upstream.cause } : {}),
+            payload: normalized.payload,
+          }),
+        )
+      }
+
+      return sendJson(
+        res,
+        200,
+        ok({
+          scene: normalized.scene,
+          center: normalized.center,
+          stats: normalized.stats,
+          upstream_path: normalized.upstreamPath,
+          dry_run: true,
+          payload: normalized.payload,
+        }),
+      )
+    }
+
+    return sendJson(res, 404, fail(ErrorCode.NOT_FOUND, { path: url.pathname }))
+  } catch (error) {
+    return sendJson(
+      res,
+      500,
+      fail(ErrorCode.INTERNAL_ERROR, {
+        message: error instanceof Error ? error.message : 'unknown error',
+      }),
+    )
+  }
+}
+
+const server = createServer(route)
+
+function listenOnPort(portToTry) {
+  server.listen(portToTry, host)
+}
+
+server.on('error', (error) => {
+  if (error?.code === 'EADDRINUSE' && activePort < preferredPort + 20) {
+    const nextPort = activePort + 1
+    console.warn(`Port ${activePort} is in use, trying ${nextPort}...`)
+    activePort = nextPort
+    listenOnPort(activePort)
+    return
+  }
+
+  throw error
+})
+
+server.on('listening', async () => {
+  await mkdir(runtimeDir, { recursive: true })
+  await writeFile(pidFile, String(process.pid), 'utf8')
+  console.log(`Lingrui local agent is running at http://${host}:${activePort}`)
+  console.log(`Runtime dir: ${runtimeDir}`)
+  console.log(`Log file: ${logFile}`)
+})
+
+listenOnPort(activePort)