nolo-cli 0.1.30 → 0.1.32

package/integrations/weather/getWeather.ts

@@ -1,24 +0,0 @@
-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

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

package/integrations/weather/routes.ts

@@ -1,31 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

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

package/integrations/weather/weatherI18n.ts

@@ -1,50 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,140 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,215 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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",
-      });
-    },
-  };
-}