@zenalexa/unicli 0.219.0 → 0.220.0

package/src/adapters/wttr/weather.ts

@@ -0,0 +1,239 @@
+/**
+ * @owner   src/adapters/wttr/weather.ts
+ * @does    Register agent-facing wttr current weather and forecast commands.
+ * @needs   wttr.in JSON endpoint, bounded forecast days, explicit empty-result errors.
+ * @feeds   surface coverage ledger, weather lookup rows, global public weather coverage.
+ * @breaks  wttr.in schema drift, non-JSON unknown-location responses, or silent empty rows hide weather failures.
+ */
+
+import { cli, Strategy } from "../../registry.js";
+
+const API_BASE = "https://wttr.in";
+
+function requireLocation(value: unknown): string {
+  const location = String(value ?? "").trim();
+  if (!location) throw new Error("wttr location cannot be empty.");
+  return location;
+}
+
+export function requireWttrDays(value: unknown): number {
+  const raw = value === undefined || value === null || value === "" ? 3 : value;
+  const days = Number(raw);
+  if (!Number.isInteger(days) || days < 1 || days > 3) {
+    throw new Error("wttr days must be an integer in [1, 3].");
+  }
+  return days;
+}
+
+function stringField(value: unknown): string {
+  return typeof value === "string" ? value : "";
+}
+
+function numberField(value: unknown): number | null {
+  const n =
+    typeof value === "number"
+      ? value
+      : typeof value === "string" && value.trim()
+        ? Number(value)
+        : NaN;
+  return Number.isFinite(n) ? n : null;
+}
+
+export function pickWeatherDescription(value: unknown): string {
+  if (!Array.isArray(value) || value.length === 0) return "";
+  const first = value[0] as { value?: unknown };
+  return typeof first.value === "string" ? first.value.trim() : "";
+}
+
+function firstArrayItem(value: unknown): Record<string, unknown> | null {
+  return Array.isArray(value) && value[0] && typeof value[0] === "object"
+    ? (value[0] as Record<string, unknown>)
+    : null;
+}
+
+export function mapCurrentWeatherRow(
+  body: Record<string, unknown>,
+  fallbackLocation: string,
+): Record<string, unknown> {
+  const current = firstArrayItem(body.current_condition);
+  if (!current)
+    throw new Error(
+      `wttr current returned no conditions for "${fallbackLocation}".`,
+    );
+  const area = firstArrayItem(body.nearest_area);
+  return {
+    location: pickWeatherDescription(area?.areaName) || fallbackLocation,
+    region: pickWeatherDescription(area?.region),
+    country: pickWeatherDescription(area?.country),
+    latitude: stringField(area?.latitude),
+    longitude: stringField(area?.longitude),
+    observedAt: stringField(current.localObsDateTime),
+    tempC: numberField(current.temp_C),
+    tempF: numberField(current.temp_F),
+    feelsLikeC: numberField(current.FeelsLikeC),
+    feelsLikeF: numberField(current.FeelsLikeF),
+    description: pickWeatherDescription(current.weatherDesc),
+    humidity: numberField(current.humidity),
+    cloudCover: numberField(current.cloudcover),
+    pressure: numberField(current.pressure),
+    precipMm: numberField(current.precipMM),
+    visibilityKm: numberField(current.visibility),
+    uvIndex: numberField(current.uvIndex),
+    windKmph: numberField(current.windspeedKmph),
+    windDirection: stringField(current.winddir16Point),
+    windDirectionDegree: numberField(current.winddirDegree),
+  };
+}
+
+export function mapForecastRows(
+  body: Record<string, unknown>,
+  days: number,
+  fallbackLocation: string,
+): Array<Record<string, unknown>> {
+  const list = Array.isArray(body.weather)
+    ? (body.weather as Array<Record<string, unknown>>)
+    : [];
+  if (list.length === 0) {
+    throw new Error(
+      `wttr forecast returned no rows for "${fallbackLocation}".`,
+    );
+  }
+  return list.slice(0, days).map((day, index) => {
+    const hourly = Array.isArray(day.hourly)
+      ? (day.hourly as Array<Record<string, unknown>>)
+      : [];
+    const noon = hourly[4] ?? hourly[0] ?? {};
+    const astro = firstArrayItem(day.astronomy);
+    return {
+      rank: index + 1,
+      date: stringField(day.date),
+      minTempC: numberField(day.mintempC),
+      maxTempC: numberField(day.maxtempC),
+      avgTempC: numberField(day.avgtempC),
+      minTempF: numberField(day.mintempF),
+      maxTempF: numberField(day.maxtempF),
+      avgTempF: numberField(day.avgtempF),
+      sunHour: numberField(day.sunHour),
+      totalSnowCm: numberField(day.totalSnow_cm),
+      uvIndex: numberField(day.uvIndex),
+      description: pickWeatherDescription(noon.weatherDesc),
+      sunrise: stringField(astro?.sunrise),
+      sunset: stringField(astro?.sunset),
+    };
+  });
+}
+
+async function fetchWeather(
+  location: string,
+  label: string,
+): Promise<Record<string, unknown>> {
+  const url = new URL(`${API_BASE}/${encodeURIComponent(location)}`);
+  url.searchParams.set("format", "j1");
+  const response = await fetch(url, {
+    headers: {
+      accept: "application/json",
+      "user-agent": "unicli-wttr (https://github.com/olo-dot-io/Uni-CLI)",
+    },
+  });
+  if (response.status === 404) throw new Error(`${label} returned no result.`);
+  if (!response.ok)
+    throw new Error(`${label} returned HTTP ${response.status}.`);
+  try {
+    return (await response.json()) as Record<string, unknown>;
+  } catch {
+    throw new Error(
+      `${label} returned non-JSON weather data for "${location}".`,
+    );
+  }
+}
+
+cli({
+  site: "wttr",
+  name: "current",
+  description: "Current weather conditions for a location",
+  domain: "wttr.in",
+  strategy: Strategy.PUBLIC,
+  args: [
+    {
+      name: "location",
+      type: "str",
+      required: true,
+      positional: true,
+      description: "City, lat/lon, airport code, or domain location",
+    },
+  ],
+  columns: [
+    "location",
+    "region",
+    "country",
+    "latitude",
+    "longitude",
+    "observedAt",
+    "tempC",
+    "tempF",
+    "feelsLikeC",
+    "feelsLikeF",
+    "description",
+    "humidity",
+    "cloudCover",
+    "pressure",
+    "precipMm",
+    "visibilityKm",
+    "uvIndex",
+    "windKmph",
+    "windDirection",
+    "windDirectionDegree",
+  ],
+  func: async (_page, kwargs) => {
+    const location = requireLocation(kwargs.location);
+    return [
+      mapCurrentWeatherRow(
+        await fetchWeather(location, "wttr current"),
+        location,
+      ),
+    ];
+  },
+});
+
+cli({
+  site: "wttr",
+  name: "forecast",
+  description: "Multi-day weather forecast for a location",
+  domain: "wttr.in",
+  strategy: Strategy.PUBLIC,
+  args: [
+    {
+      name: "location",
+      type: "str",
+      required: true,
+      positional: true,
+      description: "City, lat/lon, airport code, or domain location",
+    },
+    { name: "days", type: "int", default: 3, description: "Forecast days" },
+  ],
+  columns: [
+    "rank",
+    "date",
+    "minTempC",
+    "maxTempC",
+    "avgTempC",
+    "minTempF",
+    "maxTempF",
+    "avgTempF",
+    "sunHour",
+    "totalSnowCm",
+    "uvIndex",
+    "description",
+    "sunrise",
+    "sunset",
+  ],
+  func: async (_page, kwargs) => {
+    const location = requireLocation(kwargs.location);
+    const days = requireWttrDays(kwargs.days);
+    return mapForecastRows(
+      await fetchWeather(location, "wttr forecast"),
+      days,
+      location,
+    );
+  },
+});

package/src/adapters/xianyu/publish.test.ts

@@ -0,0 +1,210 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { resolveCommand } from "../../registry.js";
+import {
+  buildXianyuDetectSuccessScript,
+  buildXianyuFillFormScript,
+  buildXianyuPublishUrl,
+  buildXianyuSelectCategoryScript,
+  normalizeXianyuPublishArgs,
+  validateXianyuCondition,
+  validateXianyuImagePaths,
+} from "./publish.js";
+
+function pageMock(evaluateResults: unknown[]) {
+  const queue = [...evaluateResults];
+  return {
+    goto: vi.fn().mockResolvedValue(undefined),
+    wait: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn(async () => queue.shift()),
+    setFileInput: vi.fn().mockResolvedValue(undefined),
+    url: vi.fn().mockResolvedValue("https://www.goofish.com/publish"),
+  };
+}
+
+const validArgs = {
+  title: "MacBook Pro",
+  description: "成色很好，功能正常",
+  price: "5999.99",
+  condition: "轻微使用",
+  category: "笔记本",
+};
+
+describe("xianyu agent-facing publish command", () => {
+  it("normalizes and rejects publish arguments before navigation", async () => {
+    expect(buildXianyuPublishUrl()).toBe("https://www.goofish.com/publish");
+    expect(validateXianyuCondition("轻微使用")).toBe("轻微使用");
+    expect(() => validateXianyuCondition("八成新")).toThrow("must be one of");
+    expect(normalizeXianyuPublishArgs(validArgs)).toMatchObject({
+      title: "MacBook Pro",
+      price: "5999.99",
+      condition: "轻微使用",
+    });
+    expect(() =>
+      normalizeXianyuPublishArgs({ ...validArgs, title: "   " }),
+    ).toThrow("title cannot be empty");
+    expect(() =>
+      normalizeXianyuPublishArgs({ ...validArgs, price: "0" }),
+    ).toThrow("positive price");
+    expect(() =>
+      normalizeXianyuPublishArgs({ ...validArgs, price: "12.345" }),
+    ).toThrow("at most 2 decimals");
+    const command = resolveCommand("xianyu", "publish")?.command;
+    const page = pageMock([]);
+    await expect(
+      command!.func!(page, { ...validArgs, title: "" }),
+    ).rejects.toThrow("title cannot be empty");
+    expect(page.goto).not.toHaveBeenCalled();
+  });
+
+  it("validates local images strictly", () => {
+    const dir = mkdtempSync(join(tmpdir(), "unicli-xianyu-"));
+    try {
+      const png = join(dir, "a.png");
+      writeFileSync(png, "png");
+      expect(validateXianyuImagePaths(png)).toEqual([png]);
+      expect(() => validateXianyuImagePaths(join(dir, "a.bmp"))).toThrow(
+        "Unsupported image format",
+      );
+      expect(() => validateXianyuImagePaths(join(dir, "missing.png"))).toThrow(
+        "Not a valid image file",
+      );
+      expect(() =>
+        validateXianyuImagePaths(
+          "1.png,2.png,3.png,4.png,5.png,6.png,7.png,8.png,9.png,10.png",
+        ),
+      ).toThrow("at most 9");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("publishes only after each UI step reports positive proof", async () => {
+    const command = resolveCommand("xianyu", "publish")?.command;
+    const page = pageMock([
+      { hasPublishForm: true },
+      { ok: true },
+      { ok: true, filled: ["title", "description", "price", "condition"] },
+      { ok: true },
+      {
+        status: "published",
+        item_id: "123456789012",
+        url: "https://www.goofish.com/item?id=123456789012",
+      },
+    ]);
+    await expect(command!.func!(page, validArgs)).resolves.toEqual([
+      {
+        status: "published",
+        item_id: "123456789012",
+        title: "MacBook Pro",
+        price: "¥5999.99",
+        condition: "轻微使用",
+        url: "https://www.goofish.com/item?id=123456789012",
+        message: "发布成功",
+      },
+    ]);
+    expect(page.goto).toHaveBeenCalledWith("https://www.goofish.com/publish", {
+      waitUntil: "load",
+      settleMs: 3000,
+    });
+    expect(page.url).toHaveBeenCalled();
+  });
+
+  it("uploads images through Uni-CLI setFileInput(selector, files)", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "unicli-xianyu-"));
+    const image = join(dir, "a.webp");
+    writeFileSync(image, "webp");
+    try {
+      const command = resolveCommand("xianyu", "publish")?.command;
+      const page = pageMock([
+        { hasPublishForm: true },
+        { ok: true },
+        { ok: true, filled: ["title", "description", "price", "condition"] },
+        { ok: true, selector: "#upload" },
+        { ok: true },
+        {
+          status: "published",
+          item_id: "123456789012",
+          url: "https://www.goofish.com/item?id=123456789012",
+        },
+      ]);
+      await command!.func!(page, { ...validArgs, images: image });
+      expect(page.setFileInput).toHaveBeenCalledWith("#upload", [image]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("keeps auth, form, category, fill, submit, and result failures explicit", async () => {
+    const command = resolveCommand("xianyu", "publish")?.command;
+    await expect(
+      command!.func!(pageMock([{ requiresAuth: true }]), validArgs),
+    ).rejects.toThrow("login is required");
+    await expect(
+      command!.func!(pageMock([{ hasPublishForm: false }]), validArgs),
+    ).rejects.toThrow("publish form was not detected");
+    await expect(
+      command!.func!(
+        pageMock([
+          { hasPublishForm: true },
+          { ok: false, reason: "category-not-found" },
+        ]),
+        validArgs,
+      ),
+    ).rejects.toThrow("category-not-found");
+    await expect(
+      command!.func!(
+        pageMock([
+          { hasPublishForm: true },
+          { ok: true },
+          { ok: false, missing: ["price"] },
+        ]),
+        validArgs,
+      ),
+    ).rejects.toThrow("missing fields: price");
+    await expect(
+      command!.func!(
+        pageMock([
+          { hasPublishForm: true },
+          { ok: true },
+          { ok: true, filled: ["title", "description", "price", "condition"] },
+          { ok: false, reason: "disabled" },
+        ]),
+        validArgs,
+      ),
+    ).rejects.toThrow("disabled");
+    await expect(
+      command!.func!(
+        pageMock([
+          { hasPublishForm: true },
+          { ok: true },
+          { ok: true, filled: ["title", "description", "price", "condition"] },
+          { ok: true },
+          { status: "failed", message: "内容违规" },
+        ]),
+        validArgs,
+      ),
+    ).rejects.toThrow("内容违规");
+  });
+
+  it("browser scripts carry explicit proof and failure markers", () => {
+    const categoryScript = buildXianyuSelectCategoryScript("笔记本");
+    expect(categoryScript).toContain("category-trigger-not-found");
+    expect(categoryScript).toContain("category-not-found");
+    expect(categoryScript).toContain("笔记本");
+
+    const fillScript = buildXianyuFillFormScript(
+      normalizeXianyuPublishArgs(validArgs),
+    );
+    expect(fillScript).toContain("fillFirst('price'");
+    expect(fillScript).toContain("missing.push(name)");
+    expect(fillScript).toContain("filled.push('condition')");
+
+    const successScript = buildXianyuDetectSuccessScript();
+    expect(successScript).toContain("url.match(/item\\?id=(\\d+)/)");
+    expect(successScript).toContain("发布成功");
+    expect(successScript).toContain("违规");
+  });
+});