@blynkai/cli 0.1.1

package/src/cli/search-options.mjs

@@ -0,0 +1,283 @@
+const RISK_ALIAS = {
+  normal: 'E0-Normal',
+  e0: 'E0-Normal',
+  low: 'E1-Low',
+  e1: 'E1-Low',
+  medium: 'E2-Medium',
+  mid: 'E2-Medium',
+  e2: 'E2-Medium',
+  high: 'E3-High',
+  e3: 'E3-High',
+  very_high: 'E4-VeryHigh',
+  veryhigh: 'E4-VeryHigh',
+  critical: 'E4-VeryHigh',
+  e4: 'E4-VeryHigh',
+}
+
+const SENTIMENT_ALIAS = {
+  positive: 'Positive',
+  pos: 'Positive',
+  neutral: 'Neutral',
+  neu: 'Neutral',
+  negative: 'Negative',
+  neg: 'Negative',
+}
+
+const FIELD_ALIAS = {
+  title: 'title',
+  content: 'content',
+  author: 'author',
+  ocr: 'image_ocr_content',
+  image_ocr: 'image_ocr_content',
+  image_ocr_content: 'image_ocr_content',
+  asr: 'video_ocr_content',
+  video_ocr: 'video_ocr_content',
+  video_ocr_content: 'video_ocr_content',
+}
+
+const ARTICLE_TYPE_ALIAS = {
+  original: 1,
+  repost: 2,
+  forward: 2,
+  comment: 3,
+}
+
+const VALID_ALIAS = {
+  yes: 'Valid',
+  valid: 'Valid',
+  no: 'Invalid',
+  invalid: 'Invalid',
+  uncertain: 'Uncertain',
+  unsure: 'Uncertain',
+  all: '',
+}
+
+const READ_ALIAS = {
+  read: 'read',
+  unread: 'unprocessed',
+  unprocessed: 'unprocessed',
+  all: '',
+}
+
+export function normalizeSearchScene(scene) {
+  const aliases = {
+    data: 'data-center',
+    datacenter: 'data-center',
+    'data-center': 'data-center',
+    warning: 'warning-center',
+    warningcenter: 'warning-center',
+    'warning-center': 'warning-center',
+    website: 'website-stats',
+    websites: 'website-stats',
+    'website-stats': 'website-stats',
+  }
+
+  return aliases[scene] ?? scene
+}
+
+function normalizeCenter(value) {
+  const item = firstValue(value)
+  if (!item) return 'data'
+
+  const aliases = {
+    data: 'data',
+    datacenter: 'data',
+    'data-center': 'data',
+    article: 'data',
+    articles: 'data',
+    warning: 'warning',
+    warningcenter: 'warning',
+    'warning-center': 'warning',
+    alert: 'warning',
+    alerts: 'warning',
+  }
+
+  return aliases[item.toLowerCase()] ?? item
+}
+
+function normalizeStats(value) {
+  const item = firstValue(value)
+  if (!item) return ''
+
+  const aliases = {
+    website: 'website',
+    websites: 'website',
+    site: 'website',
+    sites: 'website',
+    channel: 'website',
+    channels: 'website',
+    none: '',
+    false: '',
+    no: '',
+    '0': '',
+  }
+
+  return aliases[item.toLowerCase()] ?? item
+}
+
+export function parseFlags(args) {
+  const flags = {}
+
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i]
+    if (!token.startsWith('-')) continue
+
+    const key = token.replace(/^-+/, '')
+    const values = []
+
+    while (args[i + 1] && !args[i + 1].startsWith('-')) {
+      values.push(args[i + 1])
+      i += 1
+    }
+
+    flags[key] = values.length === 0 ? true : values.length === 1 ? values[0] : values
+  }
+
+  return flags
+}
+
+export function parseSearchArgs(args) {
+  const flags = parseFlags(args)
+  const terms = []
+
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i]
+
+    if (token.startsWith('-')) {
+      while (args[i + 1] && !args[i + 1].startsWith('-')) i += 1
+      continue
+    }
+
+    const eqIndex = token.indexOf('=')
+    if (eqIndex > 0) {
+      const key = token.slice(0, eqIndex).trim()
+      const value = token.slice(eqIndex + 1).trim()
+      if (key) flags[key] = value
+      continue
+    }
+
+    terms.push(token)
+  }
+
+  return { flags, terms }
+}
+
+export function getFlag(flags, ...keys) {
+  for (const key of keys) {
+    if (flags[key] !== undefined) return flags[key]
+  }
+  return undefined
+}
+
+function toArray(value) {
+  if (value === undefined || value === null || value === true) return []
+  return Array.isArray(value) ? value : [value]
+}
+
+function splitValues(value) {
+  return toArray(value)
+    .flatMap((item) => String(item).split(','))
+    .map((item) => item.trim())
+    .filter(Boolean)
+}
+
+function firstValue(value) {
+  return splitValues(value)[0]
+}
+
+function toNumber(value) {
+  if (value === undefined || value === null || value === true || value === '') return undefined
+  const number = Number(value)
+  return Number.isFinite(number) ? number : undefined
+}
+
+function mapValues(value, aliases) {
+  return splitValues(value).map((item) => aliases[item.toLowerCase()] ?? item)
+}
+
+function mapFirstValue(value, aliases) {
+  const item = firstValue(value)
+  if (!item) return undefined
+  return aliases[item.toLowerCase()] ?? item
+}
+
+function toBoolean(value) {
+  if (value === true) return true
+  const item = firstValue(value)
+  if (!item) return false
+  return ['true', 'yes', '1', 'on'].includes(item.toLowerCase())
+}
+
+export function buildSearchBody(scene, flags) {
+  const center = normalizeCenter(getFlag(flags, 'center', 'scope', 'target') ?? scene)
+  const stats = normalizeStats(getFlag(flags, 'stats', 'stat', 'aggregate', 'aggregation'))
+  const searchMode = getFlag(flags, 'mode', 'search-mode', 'searchMode') ?? 'keyword'
+  const page = toNumber(getFlag(flags, 'page'))
+  const size = toNumber(getFlag(flags, 'size', 'limit'))
+  const semanticTop = toNumber(getFlag(flags, 'semantic_n', 'semantic-top', 'semanticTop'))
+
+  return {
+    scene:
+      stats === 'website'
+        ? 'website-stats'
+        : center === 'warning'
+          ? 'warning-center'
+          : 'data-center',
+    center,
+    time: {
+      start: getFlag(flags, 'time_s', 'time-start', 'timeStart'),
+      end: getFlag(flags, 'time_e', 'time-end', 'timeEnd'),
+      publish_start: getFlag(flags, 'publish_s', 'publish-start', 'publishStart'),
+      publish_end: getFlag(flags, 'publish_e', 'publish-end', 'publishEnd'),
+      push_start: getFlag(flags, 'push_s', 'push-start', 'pushStart'),
+      push_end: getFlag(flags, 'push_e', 'push-end', 'pushEnd'),
+    },
+    query: {
+      keywords: getFlag(flags, 'q', 'keywords', 'keyword', 'kw', 'k') ?? '',
+      keywords_must_include: splitValues(getFlag(flags, 'must', 'must_include', 'must-include', 'mustInclude')),
+      keywords_should_include: splitValues(getFlag(flags, 'should', 'should_include', 'should-include', 'shouldInclude')),
+      keywords_must_exclude: splitValues(getFlag(flags, 'exclude', 'must_exclude', 'must-exclude', 'mustExclude')),
+      search_fields: mapValues(getFlag(flags, 'field', 'fields', 'search-fields', 'search-field', 'searchFields'), FIELD_ALIAS),
+      search_mode: searchMode,
+      semantic_query: getFlag(flags, 'semantic_q', 'semantic-query', 'semanticQuery') ?? null,
+      semantic_top_n: semanticTop ?? null,
+    },
+    filters: {
+      article_categories: splitValues(getFlag(flags, 'category', 'cat', 'categories', 'c')),
+      media_channels: splitValues(getFlag(flags, 'channel', 'channels')),
+      website_names: splitValues(getFlag(flags, 'site', 'sites', 'website', 'websites')),
+      sentiment: mapValues(getFlag(flags, 'sentiment', 's'), SENTIMENT_ALIAS),
+      risk_levels: mapValues(getFlag(flags, 'risk', 'risk-levels', 'risk-level', 'riskLevels', 'r'), RISK_ALIAS),
+      media_tags: splitValues(getFlag(flags, 'media_tag', 'media_tags', 'media-tags', 'media-tag', 'mediaTags')),
+      article_type: mapValues(getFlag(flags, 'type', 'article_type', 'article-type', 'articleType'), ARTICLE_TYPE_ALIAS)
+        .map((item) => Number(item))
+        .filter((item) => Number.isFinite(item)),
+      article_id_list: splitValues(getFlag(flags, 'id', 'ids', 'article_id', 'article_ids', 'article-id-list', 'article-id', 'articleIds')),
+      article_status: getFlag(flags, 'article_status', 'article-status', 'articleStatus') ?? '',
+      is_valid: mapFirstValue(getFlag(flags, 'valid', 'is-valid', 'isValid'), VALID_ALIAS),
+      status: mapFirstValue(getFlag(flags, 'read', 'status'), READ_ALIAS),
+      review_status: getFlag(flags, 'review', 'review_status', 'review-status', 'reviewStatus'),
+      reviewer: getFlag(flags, 'reviewer'),
+      third_party: splitValues(getFlag(flags, 'source', 'third_party', 'third-party', 'thirdParty')),
+      third_party_id: getFlag(flags, 'source_id', 'third_party_id', 'third-party-id', 'thirdPartyId') ?? null,
+      collapse_field: getFlag(flags, 'collapse', 'collapse_field', 'collapse-field', 'collapseField') ?? '',
+      is_similar_collapse: toBoolean(getFlag(flags, 'similar', 'similar_collapse', 'similar-collapse', 'is-similar-collapse')),
+      topic_id: getFlag(flags, 'topic', 'topic_id', 'topic-id', 'topicId'),
+      warning_cluster_id: getFlag(flags, 'cluster', 'cluster_id', 'cluster-id', 'warning-cluster-id', 'warningClusterId'),
+      exclude_ids: splitValues(getFlag(flags, 'exclude_id', 'exclude_ids', 'exclude-ids', 'exclude-id', 'excludeIds')),
+    },
+    page: {
+      page: page ?? 1,
+      size: size ?? 10,
+    },
+    sort: {
+      field: getFlag(flags, 'sort', 'sort_field', 'sort-field', 'sortField'),
+      order: getFlag(flags, 'order', 'sort_order', 'sort-order', 'sortOrder') ?? 'desc',
+    },
+    output: {
+      dry_run: toBoolean(getFlag(flags, 'dry_run', 'dry-run', 'dryRun')),
+      stats,
+      website_stats: stats === 'website',
+    },
+  }
+}

package/src/core/config.mjs

@@ -0,0 +1,65 @@
+import { readFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const repoRoot = resolve(__dirname, '../../..')
+
+function parseEnvContent(content) {
+  const entries = {}
+
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim()
+    if (!line || line.startsWith('#')) continue
+
+    const eqIndex = line.indexOf('=')
+    if (eqIndex <= 0) continue
+
+    const key = line.slice(0, eqIndex).trim()
+    let value = line.slice(eqIndex + 1).trim()
+
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1)
+    }
+
+    entries[key] = value
+  }
+
+  return entries
+}
+
+function readEnvFile(path) {
+  try {
+    return parseEnvContent(readFileSync(path, 'utf8'))
+  } catch {
+    return {}
+  }
+}
+
+function normalizeBaseUrl(value) {
+  if (!value) return ''
+  return value.replace(/\/+$/, '')
+}
+
+function resolveEnvValue(keys) {
+  for (const key of keys) {
+    if (process.env[key]) return process.env[key]
+  }
+
+  const envFiles = ['.env.local', '.env.production.local', '.env.production', '.env.test']
+  for (const file of envFiles) {
+    const env = readEnvFile(resolve(repoRoot, file))
+    for (const key of keys) {
+      if (env[key]) return env[key]
+    }
+  }
+
+  return ''
+}
+
+export function resolveUpstreamBaseUrl() {
+  return normalizeBaseUrl(resolveEnvValue(['LINGRUI_UPSTREAM_BASE_URL', 'VITE_API_BASE_URL']))
+}

package/src/core/errors.mjs

@@ -0,0 +1,25 @@
+export const ErrorCode = {
+  AUTH_REQUIRED: 40010,
+  SESSION_EXPIRED: 40011,
+  SESSION_REVOKED: 40012,
+  RECONNECT_REQUIRED: 40013,
+  LOOPBACK_ONLY: 40014,
+  INVALID_PARAMS: 40020,
+  UNSUPPORTED_OPERATION: 40022,
+  NOT_IMPLEMENTED: 40024,
+  NOT_FOUND: 40400,
+  INTERNAL_ERROR: 50010,
+}
+
+export const ErrorMessage = {
+  [ErrorCode.AUTH_REQUIRED]: 'auth_required',
+  [ErrorCode.SESSION_EXPIRED]: 'session_expired',
+  [ErrorCode.SESSION_REVOKED]: 'session_revoked',
+  [ErrorCode.RECONNECT_REQUIRED]: 'reconnect_required',
+  [ErrorCode.LOOPBACK_ONLY]: 'loopback_only',
+  [ErrorCode.INVALID_PARAMS]: 'invalid_params',
+  [ErrorCode.UNSUPPORTED_OPERATION]: 'unsupported_operation',
+  [ErrorCode.NOT_IMPLEMENTED]: 'not_implemented',
+  [ErrorCode.NOT_FOUND]: 'not_found',
+  [ErrorCode.INTERNAL_ERROR]: 'internal_error',
+}

package/src/core/response.mjs

@@ -0,0 +1,30 @@
+import { ErrorMessage } from './errors.mjs'
+
+export function ok(data = {}) {
+  return {
+    code: 0,
+    msg: 'ok',
+    data,
+  }
+}
+
+export function fail(code, details = undefined) {
+  return {
+    code,
+    msg: ErrorMessage[code] ?? 'unknown_error',
+    ...(details ? { details } : {}),
+  }
+}
+
+export function sendJson(res, statusCode, payload) {
+  const body = JSON.stringify(payload, null, 2)
+  res.writeHead(statusCode, {
+    'content-type': 'application/json; charset=utf-8',
+    'content-length': Buffer.byteLength(body),
+    'access-control-allow-origin': '*',
+    'access-control-allow-methods': 'GET,POST,PATCH,PUT,DELETE,OPTIONS',
+    'access-control-allow-headers': 'content-type,x-request-id',
+    'access-control-allow-private-network': 'true',
+  })
+  res.end(body)
+}

package/src/core/runtime-paths.mjs

@@ -0,0 +1,6 @@
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+export const runtimeDir = join(homedir(), '.lingrui-local-agent')
+export const logFile = join(runtimeDir, 'agent.log')
+export const pidFile = join(runtimeDir, 'agent.pid')

package/src/core/session-store.mjs

@@ -0,0 +1,144 @@
+import { mkdir, readFile, stat, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { createHash, randomUUID } from 'node:crypto'
+import { runtimeDir } from './runtime-paths.mjs'
+
+const dataDir = join(runtimeDir, 'data')
+const sessionFile = join(dataDir, 'session.json')
+
+let cachedSession = null
+let cachedSessionMtimeMs = 0
+
+async function ensureDataDir() {
+  await mkdir(dataDir, { recursive: true })
+}
+
+async function persistSession(session) {
+  await ensureDataDir()
+  const persisted = {
+    ...session,
+    token: session.token
+      ? {
+          present: session.token.present,
+          masked: session.token.masked,
+          sha256: session.token.sha256,
+          value: session.token.value,
+        }
+      : session.token,
+  }
+  await writeFile(sessionFile, JSON.stringify(persisted, null, 2), 'utf8')
+  try {
+    const sessionStat = await stat(sessionFile)
+    cachedSessionMtimeMs = sessionStat.mtimeMs
+  } catch {
+    cachedSessionMtimeMs = 0
+  }
+}
+
+export async function loadSession() {
+  try {
+    const sessionStat = await stat(sessionFile)
+    if (cachedSession && cachedSessionMtimeMs === sessionStat.mtimeMs) return cachedSession
+
+    const raw = await readFile(sessionFile, 'utf8')
+    cachedSession = JSON.parse(raw)
+    cachedSessionMtimeMs = sessionStat.mtimeMs
+    return cachedSession
+  } catch {
+    cachedSession = null
+    cachedSessionMtimeMs = 0
+    return null
+  }
+}
+
+function maskToken(token) {
+  if (!token) return ''
+  if (token.length <= 12) return `${token.slice(0, 3)}***`
+  return `${token.slice(0, 6)}***${token.slice(-6)}`
+}
+
+function hashToken(token) {
+  return createHash('sha256').update(token).digest('hex')
+}
+
+export async function syncBrowserSession(payload) {
+  const now = new Date()
+  const expiresAt = payload.expiresAt
+    ? new Date(payload.expiresAt)
+    : new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000)
+  const session = {
+    sessionId: `sess_${randomUUID()}`,
+    status: 'active',
+    createdAt: now.toISOString(),
+    updatedAt: now.toISOString(),
+    expiresAt: Number.isNaN(expiresAt.getTime())
+      ? new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000).toISOString()
+      : expiresAt.toISOString(),
+    scopes: Array.isArray(payload.scopes)
+      ? payload.scopes
+      : typeof payload.scopes === 'string'
+        ? payload.scopes.split(/[,\s]+/).filter(Boolean)
+        : ['skills:use'],
+    user: {
+      username: payload.username || '',
+      nickname: payload.nickname || '',
+      institution: payload.institution || '',
+      institutionId: payload.institutionId || '',
+      role: payload.role || 'user',
+    },
+    token: {
+      present: Boolean(payload.token),
+      masked: maskToken(payload.token),
+      sha256: payload.token ? hashToken(payload.token) : '',
+      value: payload.token || '',
+    },
+  }
+
+  cachedSession = session
+  await persistSession(session)
+  console.log(
+    `[auth] synced browser session: user=${session.user.username || '-'} org=${
+      session.user.nickname || session.user.institution || '-'
+    } expiresAt=${session.expiresAt}`,
+  )
+  return session
+}
+
+export async function syncCliSession(payload) {
+  return syncBrowserSession(payload)
+}
+
+export async function revokeSession() {
+  const session = await loadSession()
+  const now = new Date().toISOString()
+
+  const revoked = {
+    ...(session ?? {
+      sessionId: null,
+      createdAt: now,
+      scopes: [],
+      user: null,
+    }),
+    status: 'revoked',
+    updatedAt: now,
+    revokedAt: now,
+  }
+
+  cachedSession = revoked
+  await persistSession(revoked)
+  return revoked
+}
+
+export async function getSessionState() {
+  const session = await loadSession()
+  if (!session) return { state: 'missing', session: null }
+  if (session.status === 'revoked') return { state: 'revoked', session }
+
+  const expiresAt = new Date(session.expiresAt).getTime()
+  if (Number.isFinite(expiresAt) && expiresAt < Date.now()) {
+    return { state: 'expired', session }
+  }
+
+  if (session.status !== 'active') return { state: 'missing', session }
+  return { state: 'active', session }
+}

package/src/data/commands.mjs

@@ -0,0 +1,37 @@
+export const availableCommands = [
+  {
+    name: 'help',
+    description: '查看命令帮助',
+    example: 'blynkai help',
+  },
+  {
+    name: 'status',
+    description: '查看 CLI 和浏览器登录状态',
+    example: 'blynkai status',
+  },
+  {
+    name: 'whoami',
+    description: '查询当前浏览器登录用户',
+    example: 'blynkai whoami',
+  },
+  {
+    name: 'list datacenter',
+    description: '查询数据中心列表（接口待接入）',
+    example: 'blynkai list datacenter --page 1 --limit 10',
+  },
+  {
+    name: 'list fengxian',
+    description: '查询风险列表（接口待接入）',
+    example: 'blynkai list fengxian --page 1 --limit 10',
+  },
+  {
+    name: 'search',
+    description: '搜索数据（接口待接入）',
+    example: 'blynkai search --kw "alibaba" --date "2026-05-01,2026-05-13"',
+  },
+  {
+    name: 'logout',
+    description: '吊销本地登录会话',
+    example: 'blynkai logout',
+  },
+]