@zenalexa/unicli 0.219.0 → 0.220.1

package/src/adapters/endoflife/product.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+import {
+  mapEndoflifeRows,
+  normalizeEndoflifeDateOrFlag,
+  requireEndoflifeProduct,
+} from "./product.js";
+
+describe("endoflife agent-facing product command", () => {
+  it("validates product slugs", () => {
+    expect(requireEndoflifeProduct(" NodeJS ")).toBe("nodejs");
+    expect(requireEndoflifeProduct("ubuntu-24.04")).toBe("ubuntu-24.04");
+    expect(() => requireEndoflifeProduct("../node")).toThrow("valid slug");
+  });
+
+  it("normalizes date and boolean lifecycle fields", () => {
+    expect(normalizeEndoflifeDateOrFlag(true)).toBe("ongoing");
+    expect(normalizeEndoflifeDateOrFlag(false)).toBeNull();
+    expect(normalizeEndoflifeDateOrFlag(" 2027-01-01 ")).toBe("2027-01-01");
+  });
+
+  it("maps cycle rows with derived EOL status", () => {
+    expect(
+      mapEndoflifeRows(
+        "nodejs",
+        [
+          {
+            cycle: "22",
+            releaseDate: "2024-04-24",
+            latest: "22.1.0",
+            latestReleaseDate: "2024-05-01",
+            lts: true,
+            support: "2027-04-30",
+            eol: "2027-04-30",
+          },
+          { cycle: "10", eol: "2021-04-30" },
+        ],
+        "2026-05-12",
+      ),
+    ).toMatchObject([
+      {
+        product: "nodejs",
+        cycle: "22",
+        lts: "ongoing",
+        eolStatus: "active",
+        url: "https://endoflife.date/nodejs",
+      },
+      { cycle: "10", eolStatus: "eol" },
+    ]);
+  });
+});

package/src/adapters/endoflife/product.ts

@@ -0,0 +1,128 @@
+/**
+ * @owner   src/adapters/endoflife/product.ts
+ * @does    Register agent-facing endoflife.date product lifecycle command.
+ * @needs   endoflife.date public API, product slug validation, date/flag normalization.
+ * @feeds   surface coverage ledger, product support lifecycle rows, version planning data.
+ * @breaks  endoflife.date API drift, weak slug validation, or silent empty rows hide lifecycle data failures.
+ */
+
+import { cli, Strategy } from "../../registry.js";
+
+const API_BASE = "https://endoflife.date/api";
+const PRODUCT_RE = /^[a-z0-9][a-z0-9._-]{0,79}$/;
+
+export function requireEndoflifeProduct(value: unknown): string {
+  const product = String(value ?? "")
+    .trim()
+    .toLowerCase();
+  if (!product) throw new Error("endoflife product cannot be empty.");
+  if (!PRODUCT_RE.test(product)) {
+    throw new Error(
+      `endoflife product "${String(value)}" is not a valid slug.`,
+    );
+  }
+  return product;
+}
+
+export function normalizeEndoflifeDateOrFlag(value: unknown): string | null {
+  if (value === true) return "ongoing";
+  if (value === false || value == null) return null;
+  if (typeof value !== "string") return null;
+  const text = value.trim();
+  return text || null;
+}
+
+function stringField(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+export function mapEndoflifeRows(
+  product: string,
+  cycles: Array<Record<string, unknown>>,
+  today: string,
+): Array<Record<string, unknown>> {
+  return cycles.map((cycle) => {
+    const eol = normalizeEndoflifeDateOrFlag(cycle.eol);
+    const eolStatus =
+      eol === "ongoing"
+        ? "ongoing"
+        : typeof eol === "string" && eol >= today
+          ? "active"
+          : typeof eol === "string"
+            ? "eol"
+            : null;
+    return {
+      product,
+      cycle: stringField(cycle.cycle),
+      releaseDate: stringField(cycle.releaseDate),
+      latest: stringField(cycle.latest),
+      latestReleaseDate: stringField(cycle.latestReleaseDate),
+      lts: normalizeEndoflifeDateOrFlag(cycle.lts),
+      support: normalizeEndoflifeDateOrFlag(cycle.support),
+      eol,
+      extendedSupport: normalizeEndoflifeDateOrFlag(cycle.extendedSupport),
+      eolStatus,
+      url: `https://endoflife.date/${product}`,
+    };
+  });
+}
+
+async function fetchJson(url: URL | string, label: string): Promise<unknown> {
+  const response = await fetch(url, {
+    headers: {
+      accept: "application/json",
+      "user-agent": "unicli-endoflife (https://github.com/olo-dot-io/Uni-CLI)",
+    },
+  });
+  if (response.status === 404) throw new Error(`${label} returned no result.`);
+  if (response.status === 429) throw new Error(`${label} returned HTTP 429.`);
+  if (!response.ok)
+    throw new Error(`${label} returned HTTP ${response.status}.`);
+  return response.json();
+}
+
+cli({
+  site: "endoflife",
+  name: "product",
+  description: "Release cycles and support dates for an endoflife.date product",
+  domain: "endoflife.date",
+  strategy: Strategy.PUBLIC,
+  args: [
+    {
+      name: "product",
+      type: "str",
+      required: true,
+      positional: true,
+      description: "endoflife.date product slug",
+    },
+  ],
+  columns: [
+    "product",
+    "cycle",
+    "releaseDate",
+    "latest",
+    "latestReleaseDate",
+    "lts",
+    "support",
+    "eol",
+    "extendedSupport",
+    "eolStatus",
+    "url",
+  ],
+  func: async (_page, kwargs) => {
+    const product = requireEndoflifeProduct(kwargs.product);
+    const body = await fetchJson(
+      `${API_BASE}/${encodeURIComponent(product)}.json`,
+      "endoflife product",
+    );
+    const rows = mapEndoflifeRows(
+      product,
+      Array.isArray(body) ? (body as Array<Record<string, unknown>>) : [],
+      new Date().toISOString().slice(0, 10),
+    );
+    if (rows.length === 0) {
+      throw new Error(`endoflife product returned no cycles for "${product}".`);
+    }
+    return rows;
+  },
+});

package/src/adapters/facebook/marketplace-extra.test.ts

@@ -0,0 +1,132 @@
+import { describe, expect, it, vi } from "vitest";
+import { resolveCommand } from "../../registry.js";
+import { requireFacebookMarketplaceLimit } from "./marketplace-extra.js";
+
+function pageMock(evaluateResults: unknown[]) {
+  return {
+    goto: vi.fn().mockResolvedValue(undefined),
+    wait: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn(async () => evaluateResults.shift()),
+  };
+}
+
+describe("facebook marketplace agent-facing commands", () => {
+  it("validates limits without silent clamps", () => {
+    expect(requireFacebookMarketplaceLimit(undefined)).toBe(20);
+    expect(requireFacebookMarketplaceLimit(2)).toBe(2);
+    expect(() => requireFacebookMarketplaceLimit(0)).toThrow(
+      "positive integer",
+    );
+    expect(() => requireFacebookMarketplaceLimit(101)).toThrow("<= 100");
+  });
+
+  it("lists Marketplace seller listings", async () => {
+    const command = resolveCommand("facebook", "marketplace-listings")?.command;
+    const page = pageMock([
+      {
+        authRequired: false,
+        rows: [
+          {
+            title: "Black electric standing desk",
+            price: "CA$80",
+            status: "Active",
+            listed: "Listed on 4/26",
+            clicks: "87",
+            actions: ["Mark as sold", "Share"],
+          },
+          {
+            title: "Large gray corduroy beanbag chair",
+            price: "CA$30",
+          },
+        ],
+      },
+    ]);
+    await expect(command!.func!(page, { limit: 1 })).resolves.toEqual([
+      {
+        index: 1,
+        title: "Black electric standing desk",
+        price: "CA$80",
+        status: "Active",
+        listed: "Listed on 4/26",
+        clicks: "87",
+        actions: "Mark as sold, Share",
+      },
+    ]);
+    expect(page.goto).toHaveBeenCalledWith(
+      "https://www.facebook.com/marketplace/you/selling/",
+    );
+    expect(page.wait).toHaveBeenCalledWith(4);
+  });
+
+  it("lists Marketplace inbox conversations", async () => {
+    const command = resolveCommand("facebook", "marketplace-inbox")?.command;
+    const page = pageMock([
+      {
+        authRequired: false,
+        rows: [
+          {
+            buyer: "Kulwant",
+            listing: "White 3-tier rolling utility cart",
+            snippet: "Can I pick up today?",
+            time: "3:43 PM",
+            unread: true,
+          },
+          {
+            buyer: "Gabriel",
+            listing: "Black electric standing desk",
+            snippet: "Yes, still available.",
+            time: "12:17 PM",
+            unread: false,
+          },
+        ],
+      },
+    ]);
+    await expect(command!.func!(page, { limit: 2 })).resolves.toEqual([
+      {
+        index: 1,
+        buyer: "Kulwant",
+        listing: "White 3-tier rolling utility cart",
+        snippet: "Can I pick up today?",
+        time: "3:43 PM",
+        unread: true,
+      },
+      {
+        index: 2,
+        buyer: "Gabriel",
+        listing: "Black electric standing desk",
+        snippet: "Yes, still available.",
+        time: "12:17 PM",
+        unread: false,
+      },
+    ]);
+    expect(page.goto).toHaveBeenCalledWith(
+      "https://www.facebook.com/marketplace/inbox/",
+    );
+    expect(page.wait).toHaveBeenCalledWith(4);
+  });
+
+  it("fails before navigation on invalid limits", async () => {
+    const command = resolveCommand("facebook", "marketplace-listings")?.command;
+    const page = pageMock([]);
+    await expect(command!.func!(page, { limit: 0 })).rejects.toThrow(
+      "positive integer",
+    );
+    expect(page.goto).not.toHaveBeenCalled();
+  });
+
+  it("classifies auth and empty Marketplace pages", async () => {
+    const listings = resolveCommand(
+      "facebook",
+      "marketplace-listings",
+    )?.command;
+    const inbox = resolveCommand("facebook", "marketplace-inbox")?.command;
+    await expect(
+      listings!.func!(pageMock([{ authRequired: true, rows: [] }]), {
+        limit: 5,
+      }),
+    ).rejects.toThrow("requires an active signed-in Facebook session");
+    await expect(
+      inbox!.func!(pageMock([{ authRequired: false, rows: [] }]), { limit: 5 }),
+    ).rejects.toThrow("No Facebook Marketplace inbox conversations");
+  });
+});

package/src/adapters/facebook/marketplace-extra.ts

@@ -0,0 +1,213 @@
+/**
+ * @owner   src/adapters/facebook/marketplace-extra.ts
+ * @does    Register agent-facing Facebook Marketplace seller listings and inbox readers.
+ * @needs   Logged-in www.facebook.com browser session with Marketplace access.
+ * @feeds   surface coverage ledger and Marketplace selling/conversation workflows.
+ * @breaks  Facebook Marketplace DOM text changes, login redirects, or unavailable Marketplace account access.
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import type { IPage } from "../../types.js";
+
+interface MarketplaceListingsResult {
+  authRequired?: unknown;
+  rows?: unknown;
+}
+
+interface MarketplaceListingRow {
+  title?: unknown;
+  price?: unknown;
+  status?: unknown;
+  listed?: unknown;
+  clicks?: unknown;
+  actions?: unknown;
+}
+
+interface MarketplaceInboxRow {
+  buyer?: unknown;
+  listing?: unknown;
+  snippet?: unknown;
+  time?: unknown;
+  unread?: unknown;
+}
+
+export function requireFacebookMarketplaceLimit(value: unknown): number {
+  const limit = Number(value ?? 20);
+  if (!Number.isInteger(limit) || limit <= 0) {
+    throw new Error("Facebook Marketplace limit must be a positive integer.");
+  }
+  if (limit > 100) {
+    throw new Error("Facebook Marketplace limit must be <= 100.");
+  }
+  return limit;
+}
+
+function requireBrowserPage(page: unknown, command: string): IPage {
+  if (!page || typeof page !== "object") {
+    throw new Error(`Browser session required for facebook ${command}.`);
+  }
+  return page as IPage;
+}
+
+function text(value: unknown): string {
+  return value == null ? "" : String(value);
+}
+
+function readRows(
+  result: MarketplaceListingsResult,
+  command: string,
+): unknown[] {
+  if (result?.authRequired) {
+    throw new Error(
+      `Facebook Marketplace ${command} requires an active signed-in Facebook session.`,
+    );
+  }
+  const rows = Array.isArray(result?.rows) ? result.rows : [];
+  if (!rows.length) {
+    throw new Error(
+      `No Facebook Marketplace ${command} rows were visible. Check Marketplace access for this account.`,
+    );
+  }
+  return rows;
+}
+
+function marketplaceListingsScript(): string {
+  return String.raw`(() => {
+    const clean = (value) => String(value || '').replace(/\u00a0/g, ' ').replace(/\s+/g, ' ').trim();
+    const allText = document.body?.innerText || '';
+    if (/log in|sign in/i.test(allText) && !/Marketplace/i.test(allText)) {
+      return { authRequired: true, rows: [] };
+    }
+    const lines = allText.split(/\n+/).map(clean).filter(Boolean);
+    const seen = new Set();
+    const rows = [];
+    for (let index = 1; index < lines.length; index += 1) {
+      if (!/^(?:CA\$|\$)\s*\d+/.test(lines[index])) continue;
+      const title = lines[index - 1];
+      if (!title || /^(Hide|All listings|Needs attention|Marketplace|Selling)$/i.test(title)) continue;
+      if (seen.has(title)) continue;
+      seen.add(title);
+      const windowLines = lines.slice(index, index + 12);
+      const status = windowLines.find((line) => /^(Active|Sold|Pending|Draft)$/i.test(line)) || '';
+      const listed = windowLines.find((line) => /Listed on\b/i.test(line))?.replace(/^·\s*/, '') || '';
+      const clickLine = windowLines.find((line) => /clicks? on listing/i.test(line)) || '';
+      const clickMatch = clickLine.match(/([\d,.]+)\s+clicks? on listing/i);
+      const actions = windowLines.filter((line) => /^(Mark as sold|Mark as available|Relist this item|Share|Boost listing)$/i.test(line));
+      rows.push({
+        title,
+        price: lines[index],
+        status,
+        listed,
+        clicks: clickMatch ? clickMatch[1] : '',
+        actions,
+      });
+    }
+    return { authRequired: false, rows };
+  })()`;
+}
+
+function marketplaceInboxScript(): string {
+  return String.raw`(() => {
+    const clean = (value) => String(value || '').replace(/[\u00a0\u202f]/g, ' ').replace(/\s+/g, ' ').trim();
+    const timeRe = /^(?:\d{1,2}:\d{2}\s?(?:AM|PM|am|pm|上午|下午)?|Mon|Tue|Wed|Thu|Fri|Sat|Sun|Today|Yesterday|\d+[mhdw]|\d+\s*(?:min|h|d|w))$/;
+    const allText = document.body?.innerText || '';
+    if (/log in|sign in/i.test(allText) && !/Marketplace/i.test(allText)) {
+      return { authRequired: true, rows: [] };
+    }
+    const lines = allText.split(/\n+/).map(clean).filter(Boolean);
+    const rows = [];
+    const seen = new Set();
+    const skipBuyer = /^(Marketplace|Browse all|Notifications|Inbox|Marketplace access|Buying|Selling|Create new listing|Create multiple listings|Location|Categories|Vehicles|Property Rentals|All|Pending payment|Paid|To be shipped|Shipped|Cash on delivery|Completed|Filter by label)$/i;
+    for (let index = 0; index < lines.length - 2; index += 1) {
+      const buyer = lines[index];
+      const meta = lines[index + 1];
+      if (skipBuyer.test(buyer) || !/^·\s+/.test(meta)) continue;
+      const listing = meta.replace(/^·\s*/, '');
+      if (!listing || /^Within\b/i.test(listing)) continue;
+      const snippet = lines[index + 2] || '';
+      const time = timeRe.test(lines[index + 3] || '') ? lines[index + 3] : '';
+      const key = buyer + '|' + listing;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const nearby = lines.slice(Math.max(0, index - 2), index + 5).join(' ');
+      rows.push({
+        buyer,
+        listing,
+        snippet,
+        time,
+        unread: /Unread/i.test(nearby),
+      });
+    }
+    return { authRequired: false, rows };
+  })()`;
+}
+
+cli({
+  site: "facebook",
+  name: "marketplace-listings",
+  description: "List your Facebook Marketplace seller listings",
+  domain: "www.facebook.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [{ name: "limit", type: "int", default: 20 }],
+  columns: ["index", "title", "price", "status", "listed", "clicks", "actions"],
+  func: async (page, kwargs) => {
+    const p = requireBrowserPage(page, "marketplace-listings");
+    const limit = requireFacebookMarketplaceLimit(kwargs.limit);
+    await p.goto("https://www.facebook.com/marketplace/you/selling/");
+    await p.wait(4);
+    const result = (await p.evaluate(
+      marketplaceListingsScript(),
+    )) as MarketplaceListingsResult;
+    return readRows(result, "seller listings")
+      .slice(0, limit)
+      .map((item, index) => {
+        const row = item as MarketplaceListingRow;
+        return {
+          index: index + 1,
+          title: text(row.title),
+          price: text(row.price),
+          status: text(row.status),
+          listed: text(row.listed),
+          clicks: text(row.clicks),
+          actions: Array.isArray(row.actions)
+            ? row.actions.map(text).join(", ")
+            : text(row.actions),
+        };
+      });
+  },
+});
+
+cli({
+  site: "facebook",
+  name: "marketplace-inbox",
+  description:
+    "List recent Facebook Marketplace buyer and seller conversations",
+  domain: "www.facebook.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [{ name: "limit", type: "int", default: 20 }],
+  columns: ["index", "buyer", "listing", "snippet", "time", "unread"],
+  func: async (page, kwargs) => {
+    const p = requireBrowserPage(page, "marketplace-inbox");
+    const limit = requireFacebookMarketplaceLimit(kwargs.limit);
+    await p.goto("https://www.facebook.com/marketplace/inbox/");
+    await p.wait(4);
+    const result = (await p.evaluate(
+      marketplaceInboxScript(),
+    )) as MarketplaceListingsResult;
+    return readRows(result, "inbox conversations")
+      .slice(0, limit)
+      .map((item, index) => {
+        const row = item as MarketplaceInboxRow;
+        return {
+          index: index + 1,
+          buyer: text(row.buyer),
+          listing: text(row.listing),
+          snippet: text(row.snippet),
+          time: text(row.time),
+          unread: Boolean(row.unread),
+        };
+      });
+  },
+});

package/src/adapters/flathub/apps.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, it } from "vitest";
+import {
+  joinFlathubList,
+  mapFlathubAppRow,
+  mapFlathubSearchRows,
+  pickLatestFlathubRelease,
+  requireFlathubAppId,
+  requireFlathubLimit,
+} from "./apps.js";
+
+describe("flathub agent-facing app commands", () => {
+  it("validates limits and AppStream ids", () => {
+    expect(requireFlathubLimit(undefined)).toBe(25);
+    expect(requireFlathubLimit("100")).toBe(100);
+    expect(() => requireFlathubLimit("101")).toThrow("flathub limit must");
+    expect(requireFlathubAppId("org.mozilla.firefox")).toBe(
+      "org.mozilla.firefox",
+    );
+    expect(() => requireFlathubAppId("firefox")).toThrow("not valid");
+  });
+
+  it("joins lists and picks latest releases", () => {
+    expect(joinFlathubList(["one", "two"], 1)).toBe("one, (+1)");
+    expect(
+      pickLatestFlathubRelease([
+        { version: "1.0", timestamp: 1 },
+        { version: "2.0", timestamp: "2" },
+      ]),
+    ).toEqual({ date: "1970-01-01", version: "2.0" });
+  });
+
+  it("maps search rows", () => {
+    expect(
+      mapFlathubSearchRows(
+        [
+          {
+            app_id: "org.mozilla.firefox",
+            name: "Firefox",
+            summary: "Browser",
+            developer_name: "Mozilla",
+            project_license: "MPL-2.0",
+            is_free_license: true,
+            main_categories: "Network",
+            installs_last_month: "100",
+            updated_at: 1,
+          },
+        ],
+        25,
+      ),
+    ).toMatchObject([
+      {
+        rank: 1,
+        appId: "org.mozilla.firefox",
+        name: "Firefox",
+        isFreeLicense: true,
+        installsLastMonth: 100,
+        updatedAt: "1970-01-01",
+      },
+    ]);
+  });
+
+  it("maps app rows", () => {
+    expect(
+      mapFlathubAppRow("org.mozilla.firefox", {
+        id: "org.mozilla.firefox",
+        name: "Firefox",
+        summary: "Browser",
+        developer_name: "Mozilla",
+        project_license: "MPL-2.0",
+        is_free_license: true,
+        is_eol: false,
+        categories: ["Network", "WebBrowser"],
+        keywords: ["web", "browser"],
+        releases: [{ version: "1.0", timestamp: 1 }],
+        urls: { homepage: "https://www.mozilla.org" },
+      }),
+    ).toMatchObject({
+      appId: "org.mozilla.firefox",
+      categories: "Network, WebBrowser",
+      latestVersion: "1.0",
+      homepage: "https://www.mozilla.org",
+      url: "https://flathub.org/apps/org.mozilla.firefox",
+    });
+  });
+});