nolo-cli 0.1.23 → 0.1.29

package/integrations/weather/getWeather.ts

@@ -0,0 +1,24 @@
+import { API_ENDPOINTS } from "../../database/config";
+
+import { WeatherQueryParams, WeatherApiResponse } from "./weatherTypes";
+export async function getWeather(
+  params: WeatherQueryParams,
+): Promise<WeatherApiResponse> {
+  const searchParams = new URLSearchParams({
+    lat: params.lat.toString(),
+    lng: params.lng.toString(),
+    params: params.params.join(","),
+    ...(params.start && { start: params.start }),
+    ...(params.end && { end: params.end }),
+    ...(params.source && { source: params.source }),
+  }).toString();
+
+  const response = await fetch(`${API_ENDPOINTS.WEATHER}?${searchParams}`);
+
+  if (!response.ok) {
+    // 如果响应状态不是2xx，抛出错误
+    throw new Error("Network response was not ok");
+  }
+
+  return response.json();
+}

package/integrations/weather/index.ts

@@ -0,0 +1,6 @@
+export * from "./weatherTypes";
+export * from "./weatherConstants";
+export * from "./weatherUtils";
+export * from "./routes";
+export * from "./weatherApi";
+export * from "./weatherService";

package/integrations/weather/routes.ts

@@ -0,0 +1,31 @@
+import { fetchWeatherData } from "./weatherService";
+
+export async function weatherRouteHandler(req, res) {
+  try {
+    // 将字符串参数转换为浮点数
+    const lat = parseFloat(req.query.lat);
+    const lng = parseFloat(req.query.lng);
+
+    // 检查是否提供了params查询参数并进行处理，此处假设params是逗号分隔的字符串
+    const params = req.query.params ? req.query.params.split(",") : [];
+    const start = req.query.start;
+    const end = req.query.end;
+    // 确保lat和lng是数字类型且params是一个字符串数组
+    if (!isNaN(lat) && !isNaN(lng) && Array.isArray(params)) {
+      const queryParams = {
+        lat,
+        lng,
+        params, // 传入处理过的params数组
+        start,
+        end,
+      };
+      const data = await fetchWeatherData(queryParams);
+
+      return res.json(data);
+    }
+    return res.status(400).json({ message: "Invalid query parameters" });
+  } catch (error) {
+    // 如果API调用失败，返回500错误及错误信息
+    return res.status(500).json({ message: error.message });
+  }
+}

package/integrations/weather/weatherApi.ts

@@ -0,0 +1,27 @@
+import { API_ENDPOINTS } from "../../database/config";
+
+import { WeatherQueryParams, WeatherApiResponse } from "./weatherTypes";
+//maybe need delete
+// export const weatherApi = api.injectEndpoints({
+//   endpoints: (builder) => ({
+//     getWeather: builder.query<WeatherApiResponse, WeatherQueryParams>({
+//       query: (params) => {
+//         const searchParams = {
+//           lat: params.lat.toString(),
+//           lng: params.lng.toString(),
+//           params: params.params.join(","),
+//           // 其他可能的查询参数, 如果它们存在
+//           ...(params.start && { start: params.start }),
+//           ...(params.end && { end: params.end }),
+//           ...(params.source && { source: params.source }),
+//         };
+//         return {
+//           url: `${API_ENDPOINTS.WEATHER}`,
+//           params: searchParams,
+//         };
+//       },
+//     }),
+//   }),
+// });
+
+export const useGetWeatherQuery = () => {};

package/integrations/weather/weatherConstants.ts

@@ -0,0 +1,2 @@
+export const WEATHER_API_ENDPOINT = '/weather';
+// ... 可能的其他常量定义

package/integrations/weather/weatherI18n.ts

@@ -0,0 +1,50 @@
+export default {
+  en: {
+    translation: {
+      time: "Time",
+      swellDirection: "Swell Dir",
+      windDirection: "Wind Dir",
+      windSpeed: "Wind Spd",
+      swellHeight: "Swell Hgt",
+      swellPeriod: "Swell Prd",
+      gust: "Gust",
+      airTemperature: "Air Temp",
+    },
+  },
+  "zh-CN": {
+    translation: {
+      time: "时间",
+      swellDirection: "浪向",
+      windDirection: "风向",
+      windSpeed: "风速",
+      swellHeight: "浪高",
+      swellPeriod: "周期",
+      gust: "阵风",
+      airTemperature: "气温",
+    },
+  },
+  "zh-Hant": {
+    translation: {
+      time: "時間",
+      swellDirection: "浪向",
+      windDirection: "風向",
+      windSpeed: "風速",
+      swellHeight: "浪高",
+      swellPeriod: "浪週期",
+      gust: "陣風",
+      airTemperature: "氣溫",
+    },
+  },
+  ja: {
+    translation: {
+      time: "時間",
+      swellDirection: "うねり方向",
+      windDirection: "風向",
+      windSpeed: "風速",
+      swellHeight: "うねり高",
+      swellPeriod: "うねり周期",
+      gust: "突風",
+      airTemperature: "気温",
+    },
+  },
+};

package/integrations/weather/weatherService.ts

@@ -0,0 +1,50 @@
+import { WeatherQueryParams, WeatherApiResponse } from "./weatherTypes";
+
+const WEATHER_API_URL = "https://api.stormglass.io/v2/weather/point";
+
+export const fetchWeatherData = async ({
+  lat,
+  lng,
+  params,
+  start,
+  end,
+  source,
+}: WeatherQueryParams): Promise<WeatherApiResponse> => {
+  const paramString = params.join(",");
+
+  const query = new URLSearchParams({
+    lat: lat.toString(),
+    lng: lng.toString(),
+    params: paramString,
+  });
+
+  if (start) {
+    query.append("start", start);
+  }
+  if (end) {
+    query.append("end", end);
+  }
+  if (source) {
+    query.append("source", source);
+  }
+
+  const queryString = query.toString();
+
+  try {
+    const key = process.env.WEATHER_API_KEY;
+    const response = await fetch(`${WEATHER_API_URL}?${queryString}`, {
+      headers: {
+        Authorization: key,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch weather data, status: ${response.status}`,
+      );
+    }
+    return response.json();
+  } catch (error) {
+    throw error; // 这里保留抛出错误，以便可以在函数调用者那里捕获异常
+  }
+};

package/integrations/weather/weatherTypes.ts

@@ -0,0 +1,140 @@
+export type WeatherParam =
+  | "time"
+  | "airTemperature"
+  | "airTemperature80m"
+  | "airTemperature100m"
+  | "airTemperature1000hpa"
+  | "airTemperature800hpa"
+  | "airTemperature500hpa"
+  | "airTemperature200hpa"
+  | "pressure"
+  | "cloudCover"
+  | "currentDirection"
+  | "currentSpeed"
+  | "gust"
+  | "humidity"
+  | "iceCover"
+  | "precipitation"
+  | "snowDepth"
+  | "seaLevel"
+  | "swellDirection"
+  | "swellHeight"
+  | "swellPeriod"
+  | "secondarySwellPeriod"
+  | "secondarySwellDirection"
+  | "secondarySwellHeight"
+  | "visibility"
+  | "waterTemperature"
+  | "waveDirection"
+  | "waveHeight"
+  | "wavePeriod"
+  | "windWaveDirection"
+  | "windWaveHeight"
+  | "windWavePeriod"
+  | "windDirection"
+  | "windDirection20m"
+  | "windDirection30m"
+  | "windDirection40m"
+  | "windDirection50m"
+  | "windDirection80m"
+  | "windDirection100m"
+  | "windDirection1000hpa"
+  | "windDirection800hpa"
+  | "windDirection500hpa"
+  | "windDirection200hpa"
+  | "windSpeed"
+  | "windSpeed20m"
+  | "windSpeed30m"
+  | "windSpeed40m"
+  | "windSpeed50m"
+  | "windSpeed80m"
+  | "windSpeed100m"
+  | "windSpeed1000hpa"
+  | "windSpeed800hpa"
+  | "windSpeed500hpa"
+  | "windSpeed200hpa";
+
+// 接口用以表达获取天气数据的请求参数
+export interface WeatherQueryParams {
+  lat: number;
+  lng: number;
+  params: WeatherParam[];
+  start?: number | string; // 可选 - 开始时间戳或ISO格式日期
+  end?: number | string; // 可选 - 结束时间戳或ISO格式日期
+  source?: string; // 可选 - 数据源
+}
+
+export interface DataSourceValue {
+  [source: string]: number | string;
+}
+
+export interface HourlyWeather {
+  time: string; // 时间点，ISO格式的日期时间字符串
+  airTemperature?: DataSourceValue; // 空气温度，不同数据源可能提供不同的数值
+  airTemperature80m?: DataSourceValue; // 80米高处的空气温度
+  airTemperature100m?: DataSourceValue; // 100米高处的空气温度
+  airTemperature1000hpa?: DataSourceValue; // 1000hpa等压面的空气温度
+  airTemperature800hpa?: DataSourceValue; // 800hpa等压面的空气温度
+  airTemperature500hpa?: DataSourceValue; // 500hpa等压面的空气温度
+  airTemperature200hpa?: DataSourceValue; // 200hpa等压面的空气温度
+  pressure?: DataSourceValue; // 气压，单位为hPa(百帕)
+  cloudCover?: DataSourceValue; // 云层覆盖率，以百分比表示
+  currentDirection?: DataSourceValue; // 海流方向，0° 表示从北方向
+  currentSpeed?: DataSourceValue; // 海流速度，单位为米每秒(m/s)
+  gust?: DataSourceValue; // 阵风，单位为米每秒(m/s)
+  humidity?: DataSourceValue; // 相对湿度, 以百分比表示
+  iceCover?: DataSourceValue; // 浮冰覆盖率，范围从 0（无冰）到 1（全覆盖）
+  precipitation?: DataSourceValue; // 降水量，单位为毫米每小时(mm/h)
+  snowDepth?: DataSourceValue; // 雪的深度，单位为米(m)
+  seaLevel?: DataSourceValue; // 海平面相对于平均海平面的高度(m)
+  swellDirection?: DataSourceValue; // 涌浪方向，0° 表示涌浪来自北方
+  swellHeight?: DataSourceValue; // 涌浪高度，单位为米(m)
+  swellPeriod?: DataSourceValue; // 涌浪周期，单位为秒(s)
+  secondarySwellPeriod?: DataSourceValue; // 副涌浪周期，单位为秒(s)
+  secondarySwellDirection?: DataSourceValue; // 副涌浪方向，0° 表示波浪来自北方
+  secondarySwellHeight?: DataSourceValue; // 副涌浪高度，单位为米(m)
+  visibility?: DataSourceValue; // 水平能见度，单位为千米(km)
+  waterTemperature?: DataSourceValue; // 水面温度，单位为摄氏度(℃)
+  waveDirection?: DataSourceValue; // 浪向，0° 表示浪向来自北方
+  waveHeight?: DataSourceValue; // 波浪高度，单位为米(m)
+  wavePeriod?: DataSourceValue; // 波浪周期，单位为秒(s)
+  windWaveDirection?: DataSourceValue; // 风浪方向，0°表示风浪来源北方
+  windWaveHeight?: DataSourceValue; // 风浪高度，单位为米(m)
+  windWavePeriod?: DataSourceValue; // 风浪周期，单位为秒(s)
+  windDirection?: DataSourceValue; // 风向, 0° 表示风来自北方
+  windDirection20m?: DataSourceValue; // 20米高处风向
+  windDirection30m?: DataSourceValue; // 30米高处风向
+  windDirection40m?: DataSourceValue; // 40米高处风向
+  windDirection50m?: DataSourceValue; // 50米高处风向
+  windDirection80m?: DataSourceValue; // 80米高处风向
+  windDirection100m?: DataSourceValue; // 100米高处风向
+  windDirection1000hpa?: DataSourceValue; // 1000hpa等压面风向
+  windDirection800hpa?: DataSourceValue; // 800hpa等压面风向
+  windDirection500hpa?: DataSourceValue; // 500hpa等压面风向
+  windDirection200hpa?: DataSourceValue; // 200hpa等压面风向
+  windSpeed?: DataSourceValue; // 10米高处的风速, 单位为米每秒(m/s)
+  windSpeed20m?: DataSourceValue; // 20米高处的风速
+  windSpeed30m?: DataSourceValue; // 30米高处的风速
+  windSpeed40m?: DataSourceValue; // 40米高处的风速
+  windSpeed50m?: DataSourceValue; // 50米高处的风速
+  windSpeed80m?: DataSourceValue; // 80米高处的风速
+  windSpeed100m?: DataSourceValue; // 100米高处的风速
+  windSpeed1000hpa?: DataSourceValue; // 1000hpa等压面的风速
+  windSpeed800hpa?: DataSourceValue; // 800hpa等压面的风速
+  windSpeed500hpa?: DataSourceValue; // 500hpa等压面的风速
+  windSpeed200hpa?: DataSourceValue; // 200hpa等压面的风速
+}
+
+export interface WeatherApiResponse {
+  hours: HourlyWeather[];
+  meta: {
+    dailyQuota: number;
+    lat: number;
+    lng: number;
+    requestCount: number;
+  };
+}
+
+export interface WeatherError {
+  message: string;
+}

package/integrations/weather/weatherUtils.ts

@@ -0,0 +1,46 @@
+import { WeatherQueryParams } from ".";
+import { set } from "date-fns";
+function getTodayAtFiveAM(): number {
+  const now = new Date();
+  const todayAtFiveAM = set(now, {
+    hours: 5,
+    minutes: 0,
+    seconds: 0,
+    milliseconds: 0,
+  });
+  return todayAtFiveAM.getTime();
+}
+export const parseWeatherParams = ({ lat, lng }): WeatherQueryParams => {
+  return {
+    lat,
+    lng,
+    start: getTodayAtFiveAM(),
+    params: [
+      "airTemperature",
+      "pressure",
+      "cloudCover",
+      "currentDirection",
+      "currentSpeed",
+      "gust",
+      "humidity",
+      "precipitation",
+      "seaLevel",
+      "swellDirection",
+      "swellHeight",
+      "swellPeriod",
+      "secondarySwellPeriod",
+      "secondarySwellDirection",
+      "secondarySwellHeight",
+      "visibility",
+      "waterTemperature",
+      "waveDirection",
+      "waveHeight",
+      "wavePeriod",
+      "windWaveDirection",
+      "windWaveHeight",
+      "windWavePeriod",
+      "windDirection",
+      "windSpeed",
+    ],
+  };
+};

package/integrations/x-reader/backends/localBrowser.ts

@@ -0,0 +1,215 @@
+import {
+  createXReadFailure,
+  type XPost,
+  type XReaderBackend,
+  type XReadResult,
+  type XThread,
+} from "../types";
+import { parseVisibleXPostText } from "../visibleTextParser";
+
+export type LocalBrowserReader = {
+  readVisiblePost(url: string): Promise<XReadResult<XPost>>;
+  readVisibleThread(url: string): Promise<XReadResult<XThread>>;
+};
+
+export function createLocalBrowserBackend(
+  reader?: LocalBrowserReader,
+): XReaderBackend {
+  return {
+    name: "desktop_local_browser",
+    async readPost(url: string): Promise<XReadResult<XPost>> {
+      if (!reader) {
+        return createXReadFailure({
+          code: "not_connected",
+          message: "Local browser reader is not connected.",
+          nextStep:
+            "Start the desktop browser bridge or inject a LocalBrowserReader.",
+          backend: "desktop_local_browser",
+        });
+      }
+      return reader.readVisiblePost(url);
+    },
+    async readThread(url: string): Promise<XReadResult<XThread>> {
+      if (!reader) {
+        return createXReadFailure({
+          code: "not_connected",
+          message: "Local browser reader is not connected.",
+          nextStep:
+            "Start the desktop browser bridge or inject a LocalBrowserReader.",
+          backend: "desktop_local_browser",
+        });
+      }
+      return reader.readVisibleThread(url);
+    },
+  };
+}
+
+export type PlaywrightXReaderOptions = {
+  headless?: boolean;
+  timeoutMs?: number;
+  channel?: "chrome" | "msedge";
+};
+
+export type CdpXReaderOptions = {
+  endpoint: string;
+  timeoutMs?: number;
+};
+
+export function createPlaywrightXReader(
+  options: PlaywrightXReaderOptions = {},
+): LocalBrowserReader {
+  const timeoutMs = options.timeoutMs ?? 20000;
+
+  async function closeBrowser(browser: { close(): Promise<void> } | undefined) {
+    if (!browser) {
+      return;
+    }
+
+    await Promise.race([
+      browser.close(),
+      new Promise<void>((resolve) => setTimeout(resolve, 3000)),
+    ]);
+  }
+
+  return {
+    async readVisiblePost(url: string): Promise<XReadResult<XPost>> {
+      const fetchedAt = new Date().toISOString();
+      let browser: { close(): Promise<void> } | undefined;
+
+      try {
+        const { chromium } = await import("playwright");
+        browser = await chromium.launch({
+          headless: options.headless ?? true,
+          timeout: timeoutMs,
+          channel: options.channel,
+        });
+        const page = await browser.newPage({
+          viewport: { width: 1280, height: 900 },
+        });
+        page.setDefaultTimeout(timeoutMs);
+        await page.goto(url, {
+          waitUntil: "domcontentloaded",
+          timeout: timeoutMs,
+        });
+        await page.waitForTimeout(2500);
+        const visibleText = await page.locator("body").innerText({
+          timeout: timeoutMs,
+        });
+
+        return parseVisibleXPostText(visibleText, {
+          url,
+          fetchedAt,
+        });
+      } catch (error) {
+        return createXReadFailure({
+          code: "network_error",
+          message:
+            error instanceof Error
+              ? error.message
+              : "Unknown local browser read failure.",
+          nextStep:
+            "Check network access, Playwright browser installation, and X login/challenge state.",
+          backend: "desktop_local_browser",
+          fetchedAt,
+        });
+      } finally {
+        await closeBrowser(browser);
+      }
+    },
+    async readVisibleThread(url: string): Promise<XReadResult<XThread>> {
+      const postResult = await this.readVisiblePost(url);
+      if (!postResult.ok) {
+        return postResult;
+      }
+
+      return {
+        ok: true,
+        backend: "desktop_local_browser",
+        fetchedAt: postResult.fetchedAt,
+        data: {
+          root: postResult.data,
+          posts: [postResult.data],
+          completeness: "single_post",
+          missingReason: "unsupported_content",
+        },
+      };
+    },
+  };
+}
+
+export function createCdpXReader(options: CdpXReaderOptions): LocalBrowserReader {
+  const timeoutMs = options.timeoutMs ?? 20000;
+
+  return {
+    async readVisiblePost(url: string): Promise<XReadResult<XPost>> {
+      const fetchedAt = new Date().toISOString();
+      let browser: { close(): Promise<void>; newPage(): Promise<any> } | undefined;
+
+      try {
+        const { chromium } = await import("playwright");
+        browser = await chromium.connectOverCDP(options.endpoint, {
+          timeout: timeoutMs,
+        });
+        const page = await browser.newPage();
+        page.setDefaultTimeout(timeoutMs);
+        await page.setViewportSize({ width: 1280, height: 900 });
+        await page.goto(url, {
+          waitUntil: "domcontentloaded",
+          timeout: timeoutMs,
+        });
+        await page.waitForTimeout(2500);
+        const visibleText = await page.locator("body").innerText({
+          timeout: timeoutMs,
+        });
+
+        return parseVisibleXPostText(visibleText, {
+          url,
+          fetchedAt,
+        });
+      } catch (error) {
+        return createXReadFailure({
+          code: "network_error",
+          message:
+            error instanceof Error
+              ? error.message
+              : "Unknown CDP browser read failure.",
+          nextStep:
+            "Start Chrome with --remote-debugging-port or check the CDP endpoint.",
+          backend: "desktop_local_browser",
+          fetchedAt,
+        });
+      } finally {
+        await closeCdp(browser);
+      }
+    },
+    async readVisibleThread(url: string): Promise<XReadResult<XThread>> {
+      const postResult = await this.readVisiblePost(url);
+      if (!postResult.ok) {
+        return postResult;
+      }
+
+      return {
+        ok: true,
+        backend: "desktop_local_browser",
+        fetchedAt: postResult.fetchedAt,
+        data: {
+          root: postResult.data,
+          posts: [postResult.data],
+          completeness: "single_post",
+          missingReason: "unsupported_content",
+        },
+      };
+    },
+  };
+}
+
+async function closeCdp(browser: { close(): Promise<void> } | undefined) {
+  if (!browser) {
+    return;
+  }
+
+  await Promise.race([
+    browser.close(),
+    new Promise<void>((resolve) => setTimeout(resolve, 3000)),
+  ]);
+}

package/integrations/x-reader/backends/publicFallback.ts

@@ -0,0 +1,31 @@
+import {
+  createXReadFailure,
+  type XPost,
+  type XReaderBackend,
+  type XReadResult,
+  type XThread,
+} from "../types";
+
+export function createPublicFallbackBackend(): XReaderBackend {
+  return {
+    name: "public_fallback",
+    async readPost(url: string): Promise<XReadResult<XPost>> {
+      return createXReadFailure({
+        code: "not_connected",
+        message: `No public fallback reader has been configured for ${url}.`,
+        nextStep:
+          "Use the fixture backend for offline tests or the local browser backend for a live spike.",
+        backend: "public_fallback",
+      });
+    },
+    async readThread(url: string): Promise<XReadResult<XThread>> {
+      return createXReadFailure({
+        code: "not_connected",
+        message: `No public fallback thread reader has been configured for ${url}.`,
+        nextStep:
+          "Use the fixture backend for offline tests or the local browser backend for a live spike.",
+        backend: "public_fallback",
+      });
+    },
+  };
+}