@zenalexa/unicli 0.220.0 → 0.221.0

package/src/adapters/lens/get.yaml

@@ -0,0 +1,64 @@
+# Lens.org single-record fetch.
+#
+# verification_status: blocked-by-subscription
+#
+# Lens "patent/search" is the only retrieval endpoint they expose publicly;
+# get is implemented as a one-record query by `doc_key` (publication_number).
+site: lens
+name: get
+description: Retrieve a single Lens.org patent record by publication number
+domain: api.lens.org
+type: web-api
+strategy: header
+
+args:
+  publication_number:
+    type: str
+    required: true
+    positional: true
+
+pipeline:
+  - fetch:
+      url: https://api.lens.org/patent/search
+      method: POST
+      headers:
+        Authorization: "Bearer ${{ env.LENS_API_TOKEN || '' }}"
+        Content-Type: application/json
+      body:
+        query:
+          term:
+            doc_key: "${{ args.publication_number }}"
+        size: 1
+
+  - select: data
+
+  - map:
+      publication_number: "${{ item.doc_key || item.lens_id }}"
+      title: "${{ item.biblio ? (item.biblio.invention_title ? item.biblio.invention_title[0].text : '') : '' }}"
+      abstract: "${{ item.abstract ? (Array.isArray(item.abstract) ? (item.abstract[0] && item.abstract[0].text) : item.abstract) : '' }}"
+      kind_code: "${{ item.biblio && item.biblio.publication_reference ? (item.biblio.publication_reference.kind || '') : '' }}"
+      filing_date: "${{ item.biblio ? (item.biblio.application_reference ? item.biblio.application_reference.date : '') : '' }}"
+      publication_date: "${{ item.date_published || '' }}"
+      priority_date: "${{ item.biblio && item.biblio.priority_claims && item.biblio.priority_claims.claims ? item.biblio.priority_claims.claims[0].date : '' }}"
+      family_id: "${{ item.families ? item.families.simple_family.family_id : '' }}"
+      inventors: "${{ JSON.stringify((function(){ var p=item.biblio && item.biblio.parties; if(!p || !p.inventors) return []; return p.inventors.map(i => ({ name: i.extracted_name ? (i.extracted_name.value || '') : (i.name || ''), country: i.residence || undefined })).filter(x => x.name); })()) }}"
+      assignees: "${{ JSON.stringify((function(){ var p=item.biblio && item.biblio.parties; if(!p || !p.applicants) return []; return p.applicants.map(a => ({ name: a.extracted_name ? (a.extracted_name.value || '') : (a.name || ''), country: a.residence || undefined })).filter(x => x.name); })()) }}"
+      classifications: "${{ JSON.stringify((function(){ var c = item.biblio && item.biblio.classifications_cpc && item.biblio.classifications_cpc.classifications; var out = []; if(c){ for (var i=0;i<c.length;i++) out.push({ scheme: 'cpc', code: c[i].symbol || '' }); } var ipc = item.biblio && item.biblio.classifications_ipcr && item.biblio.classifications_ipcr.classifications; if(ipc){ for (var j=0;j<ipc.length;j++) out.push({ scheme: 'ipc', code: ipc[j].symbol || '' }); } return out.filter(x => x.code); })()) }}"
+      cited_by_count: "${{ item.biblio && item.biblio.cited_by ? (item.biblio.cited_by.patent_count || 0) : '' }}"
+      cites_count: "${{ item.biblio && item.biblio.references_cited && item.biblio.references_cited.patent_count !== undefined ? item.biblio.references_cited.patent_count : '' }}"
+      claims_count: "${{ item.claims_count !== undefined ? item.claims_count : '' }}"
+      legal_status: "${{ item.legal_status ? (item.legal_status.patent_status || '') : '' }}"
+      source_url: "https://www.lens.org/lens/patent/${{ item.lens_id }}"
+      source_adapter: lens
+      retrieved_at: "${{ now }}"
+
+  - limit: 1
+
+columns: [publication_number, title, publication_date]
+
+capabilities: ["http.fetch", "patent.get"]
+minimum_capability: http.fetch
+trust: public
+confidentiality: public
+quarantine: false
+schema_version: v2

package/src/adapters/lens/search.yaml

@@ -0,0 +1,82 @@
+# Lens.org Patent API — POST JSON DSL search.
+#
+# verification_status: blocked-by-subscription
+#
+# Lens.org Patents is a free-to-search, paid-to-API service from Cambia.
+# Institutional / commercial users get tokens via the Lens Toolkit subscription
+# (https://www.lens.org/lens/user/subscriptions). The token is static once
+# issued; no refresh dance, no rotation — set $LENS_API_TOKEN and the adapter
+# works. Until the env var is present, every command emits a structured
+# blocked-by-key envelope so agents can repair by guiding the user through
+# subscription setup rather than retrying the API.
+site: lens
+name: search
+description: Search Lens.org's combined patent corpus via the Scholarly Works DSL
+domain: api.lens.org
+type: web-api
+strategy: header
+
+args:
+  query:
+    type: str
+    required: true
+    positional: true
+    description: Free-text query — mapped to the Lens DSL `query_string`
+  limit:
+    type: int
+    default: 20
+    description: Maximum records returned (Lens caps at 1000)
+  date_from:
+    type: str
+    default: ""
+    description: ISO date — minimum publication date
+
+pipeline:
+  - fetch:
+      url: https://api.lens.org/patent/search
+      method: POST
+      headers:
+        Authorization: "Bearer ${{ env.LENS_API_TOKEN || '' }}"
+        Content-Type: application/json
+      body:
+        query:
+          query_string:
+            query: "${{ args.query }}"
+        size: "${{ args.limit }}"
+        from: 0
+
+  - select: data
+
+  # Lens.org JSON `biblio` is the rich envelope. `_score` is Lens's
+  # relevance score, naturally a float; pass through as relevance_score.
+  - map:
+      publication_number: "${{ item.doc_key || item.lens_id }}"
+      title: "${{ item.biblio ? (item.biblio.invention_title ? item.biblio.invention_title[0].text : '') : '' }}"
+      abstract: "${{ item.abstract ? (Array.isArray(item.abstract) ? (item.abstract[0] && item.abstract[0].text) : item.abstract) : '' }}"
+      publication_date: "${{ item.date_published || '' }}"
+      filing_date: "${{ item.biblio ? (item.biblio.application_reference ? item.biblio.application_reference.date : '') : '' }}"
+      priority_date: "${{ item.biblio && item.biblio.priority_claims && item.biblio.priority_claims.claims ? item.biblio.priority_claims.claims[0].date : '' }}"
+      kind_code: "${{ item.biblio && item.biblio.publication_reference ? (item.biblio.publication_reference.kind || '') : '' }}"
+      family_id: "${{ item.families ? item.families.simple_family.family_id : '' }}"
+      inventors: "${{ JSON.stringify((function(){ var p=item.biblio && item.biblio.parties; if(!p || !p.inventors) return []; return p.inventors.map(i => ({ name: i.extracted_name ? (i.extracted_name.value || '') : (i.name || ''), country: i.residence || undefined })).filter(x => x.name); })()) }}"
+      assignees: "${{ JSON.stringify((function(){ var p=item.biblio && item.biblio.parties; if(!p || !p.applicants) return []; return p.applicants.map(a => ({ name: a.extracted_name ? (a.extracted_name.value || '') : (a.name || ''), country: a.residence || undefined })).filter(x => x.name); })()) }}"
+      classifications: "${{ JSON.stringify((function(){ var c = item.biblio && item.biblio.classifications_cpc && item.biblio.classifications_cpc.classifications; var out = []; if(c){ for (var i=0;i<c.length;i++) out.push({ scheme: 'cpc', code: c[i].symbol || '' }); } var ipc = item.biblio && item.biblio.classifications_ipcr && item.biblio.classifications_ipcr.classifications; if(ipc){ for (var j=0;j<ipc.length;j++) out.push({ scheme: 'ipc', code: ipc[j].symbol || '' }); } return out.filter(x => x.code); })()) }}"
+      cited_by_count: "${{ item.biblio && item.biblio.cited_by ? (item.biblio.cited_by.patent_count || 0) : '' }}"
+      cites_count: "${{ item.biblio && item.biblio.references_cited && item.biblio.references_cited.patent_count !== undefined ? item.biblio.references_cited.patent_count : '' }}"
+      claims_count: "${{ item.claims_count !== undefined ? item.claims_count : '' }}"
+      relevance_score: "${{ item._score !== undefined ? item._score : '' }}"
+      source_url: "https://www.lens.org/lens/patent/${{ item.lens_id }}"
+      source_adapter: lens
+      retrieved_at: "${{ now }}"
+
+  - limit: ${{ args.limit }}
+
+columns: [publication_number, title, publication_date, source_adapter]
+
+# schema-v2 metadata
+capabilities: ["http.fetch", "patent.search"]
+minimum_capability: http.fetch
+trust: public
+confidentiality: public
+quarantine: false
+schema_version: v2

package/src/adapters/mangadex/web.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest";
+import { resolveCommand } from "../../registry.js";
+import { mapMangaDexAuthors, mapMangaDexManga } from "./web.js";
+
+describe("mangadex public commands", () => {
+  it("registers manga and author search", () => {
+    expect(
+      Object.keys(resolveCommand("mangadex", "manga")!.adapter.commands),
+    ).toEqual(expect.arrayContaining(["manga", "authors"]));
+  });
+
+  it("exposes year, sort, and content rating controls for recent manga lookup", () => {
+    expect(resolveCommand("mangadex", "manga")!.command.adapterArgs).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ name: "year", type: "int" }),
+        expect.objectContaining({
+          name: "sort",
+          choices: expect.arrayContaining(["latest", "followed", "relevance"]),
+        }),
+        expect.objectContaining({
+          name: "content-rating",
+          choices: expect.arrayContaining(["safe", "suggestive", "erotica"]),
+        }),
+      ]),
+    );
+  });
+
+  it("maps manga rows", () => {
+    expect(
+      mapMangaDexManga([
+        {
+          id: "m1",
+          attributes: { title: { en: "Hanabi" }, status: "ongoing" },
+        },
+      ]),
+    ).toMatchObject([
+      { rank: 1, id: "m1", title: "Hanabi", status: "ongoing" },
+    ]);
+  });
+
+  it("maps author rows", () => {
+    expect(
+      mapMangaDexAuthors([{ id: "a1", attributes: { name: "Yuzusoft" } }]),
+    ).toMatchObject([{ rank: 1, id: "a1", name: "Yuzusoft" }]);
+  });
+});

package/src/adapters/mangadex/web.ts

@@ -0,0 +1,210 @@
+/**
+ * @owner   src/adapters/mangadex/web.ts
+ * @does    Register MangaDex public manga and author search commands.
+ * @needs   MangaDex public API and relationship include semantics.
+ * @feeds   Manga/doujin-adjacent title and creator discovery.
+ * @breaks  MangaDex API schema or public rate limits can block lookup.
+ */
+
+import { USER_AGENT } from "../../constants.js";
+import { cli, Strategy } from "../../registry.js";
+
+const API = "https://api.mangadex.org";
+
+function str(value: unknown): string {
+  return value === undefined || value === null ? "" : String(value);
+}
+
+function required(value: unknown, label: string): string {
+  const text = str(value).trim();
+  if (!text) throw new Error(`mangadex ${label} cannot be empty.`);
+  return text;
+}
+
+function requireLimit(value: unknown): number {
+  if (value === undefined || value === null || value === "") return 10;
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1 || n > 50) {
+    throw new Error("mangadex limit must be an integer in [1, 50].");
+  }
+  return n;
+}
+
+function optionalYear(value: unknown): number | undefined {
+  if (value === undefined || value === null || value === "") return undefined;
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1900 || n > 2100) {
+    throw new Error("mangadex year must be an integer in [1900, 2100].");
+  }
+  return n;
+}
+
+const SORT_PARAMS: Record<string, [string, string] | undefined> = {
+  relevance: undefined,
+  latest: ["order[latestUploadedChapter]", "desc"],
+  followed: ["order[followedCount]", "desc"],
+  year: ["order[year]", "desc"],
+};
+
+function applySort(url: URL, value: unknown): void {
+  const key = String(value ?? "relevance").trim();
+  const spec = SORT_PARAMS[key];
+  if (!(key in SORT_PARAMS)) {
+    throw new Error(
+      `mangadex sort must be one of: ${Object.keys(SORT_PARAMS).join(", ")}.`,
+    );
+  }
+  if (spec) url.searchParams.set(spec[0], spec[1]);
+}
+
+const CONTENT_RATINGS = new Set([
+  "safe",
+  "suggestive",
+  "erotica",
+  "pornographic",
+  "all",
+]);
+
+function applyContentRating(url: URL, value: unknown): void {
+  if (value === undefined || value === null || value === "") return;
+  const rating = String(value).trim();
+  if (!CONTENT_RATINGS.has(rating)) {
+    throw new Error(
+      `mangadex content_rating must be one of: ${Array.from(CONTENT_RATINGS).join(", ")}.`,
+    );
+  }
+  if (rating !== "all") url.searchParams.append("contentRating[]", rating);
+}
+
+async function getJson(url: URL): Promise<unknown[]> {
+  const response = await fetch(url, {
+    headers: { Accept: "application/json", "User-Agent": USER_AGENT },
+  });
+  if (!response.ok)
+    throw new Error(`mangadex request failed with HTTP ${response.status}.`);
+  const data = (await response.json()) as { data?: unknown[]; result?: string };
+  if (data.result && data.result !== "ok")
+    throw new Error(`mangadex API returned ${data.result}.`);
+  return data.data ?? [];
+}
+
+function localized(values: unknown): string {
+  const obj =
+    values && typeof values === "object"
+      ? (values as Record<string, unknown>)
+      : {};
+  return str(
+    obj.en || obj.ja || obj["ja-ro"] || obj.zh || Object.values(obj)[0],
+  );
+}
+
+export function mapMangaDexManga(rows: unknown[]): Record<string, unknown>[] {
+  return rows.map((row, index) => {
+    const item = row as Record<string, unknown>;
+    const attrs =
+      (item.attributes as Record<string, unknown> | undefined) ?? {};
+    return {
+      rank: index + 1,
+      id: item.id,
+      title: localized(attrs.title),
+      status: str(attrs.status),
+      year: attrs.year ?? null,
+      content_rating: str(attrs.contentRating),
+      latest_uploaded_chapter: str(attrs.latestUploadedChapter),
+      description: localized(attrs.description).slice(0, 700),
+      url: `https://mangadex.org/title/${item.id}`,
+    };
+  });
+}
+
+export function mapMangaDexAuthors(rows: unknown[]): Record<string, unknown>[] {
+  return rows.map((row, index) => {
+    const item = row as Record<string, unknown>;
+    const attrs =
+      (item.attributes as Record<string, unknown> | undefined) ?? {};
+    return {
+      rank: index + 1,
+      id: item.id,
+      name: str(attrs.name),
+      twitter: str(attrs.twitter),
+      pixiv: str(attrs.pixiv),
+      website: str(attrs.website),
+      url: `https://mangadex.org/author/${item.id}`,
+    };
+  });
+}
+
+async function searchManga(kwargs: Record<string, unknown>) {
+  const query = required(kwargs.query, "query");
+  const url = new URL(`${API}/manga`);
+  url.searchParams.set("title", query);
+  url.searchParams.set("limit", String(requireLimit(kwargs.limit)));
+  const year = optionalYear(kwargs.year);
+  if (year) url.searchParams.set("year", String(year));
+  applySort(url, kwargs.sort);
+  applyContentRating(url, kwargs["content-rating"]);
+  url.searchParams.append("includes[]", "author");
+  url.searchParams.append("includes[]", "artist");
+  const rows = mapMangaDexManga(await getJson(url));
+  if (rows.length === 0)
+    throw new Error(`No MangaDex manga found for "${query}".`);
+  return rows;
+}
+
+async function searchAuthors(kwargs: Record<string, unknown>) {
+  const query = required(kwargs.query, "query");
+  const url = new URL(`${API}/author`);
+  url.searchParams.set("name", query);
+  url.searchParams.set("limit", String(requireLimit(kwargs.limit)));
+  const rows = mapMangaDexAuthors(await getJson(url));
+  if (rows.length === 0)
+    throw new Error(`No MangaDex authors found for "${query}".`);
+  return rows;
+}
+
+const SEARCH_ARGS = [
+  { name: "query", type: "str" as const, required: true, positional: true },
+  { name: "limit", type: "int" as const, default: 10 },
+];
+
+const MANGA_ARGS = [
+  { name: "query", type: "str" as const, required: true, positional: true },
+  { name: "limit", type: "int" as const, default: 10 },
+  { name: "year", type: "int" as const },
+  {
+    name: "sort",
+    type: "str" as const,
+    default: "relevance",
+    choices: ["relevance", "latest", "followed", "year"],
+  },
+  {
+    name: "content-rating",
+    type: "str" as const,
+    choices: ["safe", "suggestive", "erotica", "pornographic", "all"],
+  },
+];
+
+cli({
+  site: "mangadex",
+  name: "manga",
+  description:
+    "Search MangaDex manga by Japanese title, romaji, alias, or keyword",
+  domain: "mangadex.org",
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: MANGA_ARGS,
+  columns: ["rank", "id", "title", "status", "year", "content_rating", "url"],
+  func: async (_page, kwargs) => searchManga(kwargs),
+});
+
+cli({
+  site: "mangadex",
+  name: "authors",
+  description: "Search MangaDex authors and artists by public name or romaji",
+  domain: "mangadex.org",
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: SEARCH_ARGS,
+  columns: ["rank", "id", "name", "twitter", "pixiv", "website", "url"],
+  func: async (_page, kwargs) => searchAuthors(kwargs),
+});

package/src/adapters/mastodon/statuses.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it } from "vitest";
+
+import { mapMastodonStatusRows, normalizeMastodonAccount } from "./statuses.js";
+
+describe("mastodon statuses adapter helpers", () => {
+  it("normalizes account handles and instance overrides", () => {
+    expect(normalizeMastodonAccount("gargron@mastodon.social")).toEqual({
+      acct: "gargron",
+      instance: "mastodon.social",
+    });
+
+    expect(normalizeMastodonAccount("@gargron", "mastodon.social")).toEqual({
+      acct: "gargron",
+      instance: "mastodon.social",
+    });
+  });
+
+  it("maps API statuses into stable social rows", () => {
+    expect(
+      mapMastodonStatusRows(
+        [
+          {
+            created_at: "2026-05-14T10:00:00.000Z",
+            content: "<p>Hello <strong>fediverse</strong></p>",
+            url: "https://mastodon.social/@gargron/1",
+            reblogs_count: 2,
+            favourites_count: 3,
+            replies_count: 4,
+            account: { acct: "gargron", display_name: "Gargron" },
+          },
+        ],
+        10,
+      ),
+    ).toEqual([
+      {
+        rank: 1,
+        author: "Gargron",
+        handle: "@gargron",
+        content: "Hello fediverse",
+        reblogs: 2,
+        favorites: 3,
+        replies: 4,
+        url: "https://mastodon.social/@gargron/1",
+        date: "2026-05-14T10:00:00.000Z",
+      },
+    ]);
+  });
+
+  it("drops empty activity rows and decodes common HTML entities", () => {
+    expect(
+      mapMastodonStatusRows(
+        [
+          {
+            created_at: "2026-05-14T10:00:00.000Z",
+            content: "",
+            url: "https://mastodon.social/users/Gargron/statuses/1/activity",
+            account: { acct: "Gargron", display_name: "Eugen Rochko" },
+          },
+          {
+            created_at: "2026-05-14T11:00:00.000Z",
+            content: "<p>Don&#39;t escape &amp; ship</p>",
+            url: "https://mastodon.social/@Gargron/2",
+            account: { acct: "Gargron", display_name: "Eugen Rochko" },
+          },
+        ],
+        10,
+      ),
+    ).toEqual([
+      {
+        rank: 1,
+        author: "Eugen Rochko",
+        handle: "@Gargron",
+        content: "Don't escape & ship",
+        reblogs: 0,
+        favorites: 0,
+        replies: 0,
+        url: "https://mastodon.social/@Gargron/2",
+        date: "2026-05-14T11:00:00.000Z",
+      },
+    ]);
+  });
+});

package/src/adapters/mastodon/statuses.ts

@@ -0,0 +1,208 @@
+/**
+ * @owner   Mastodon user status adapter.
+ * @does    Register a public read command for recent statuses by account handle.
+ * @needs   Mastodon-compatible public API endpoints for account lookup and statuses.
+ * @feeds   Social research workflows and social capability coverage.
+ * @breaks  Instance API drift, blocked public egress, or accounts hidden from public lookup.
+ */
+
+import { USER_AGENT } from "../../constants.js";
+import { cli, Strategy } from "../../registry.js";
+
+interface MastodonAccount {
+  id?: unknown;
+  acct?: unknown;
+  display_name?: unknown;
+}
+
+interface MastodonStatus {
+  created_at?: unknown;
+  content?: unknown;
+  url?: unknown;
+  reblogs_count?: unknown;
+  favourites_count?: unknown;
+  replies_count?: unknown;
+  account?: MastodonAccount;
+}
+
+export interface MastodonAccountRef {
+  acct: string;
+  instance: string;
+}
+
+export interface MastodonStatusRow {
+  rank: number;
+  author: string;
+  handle: string;
+  content: string;
+  reblogs: number;
+  favorites: number;
+  replies: number;
+  url: string;
+  date: string;
+}
+
+function cleanString(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function numberValue(value: unknown): number {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+function stripHtml(value: unknown): string {
+  return cleanString(value)
+    .replace(/<[^>]*>/g, "")
+    .replace(/&nbsp;/g, " ")
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+export function normalizeMastodonAccount(
+  input: string,
+  instanceOverride = "mastodon.social",
+): MastodonAccountRef {
+  const trimmed = input.trim().replace(/^@/, "");
+  if (!trimmed) throw new Error("Mastodon account cannot be empty");
+  const parts = trimmed.split("@").filter(Boolean);
+  if (parts.length > 2) {
+    throw new Error(`Invalid Mastodon account: ${input}`);
+  }
+  const acct = parts[0];
+  const instance = parts[1] ?? instanceOverride.trim();
+  if (!acct || !instance) {
+    throw new Error(`Invalid Mastodon account: ${input}`);
+  }
+  return { acct, instance };
+}
+
+export function mapMastodonStatusRows(
+  statuses: MastodonStatus[],
+  limit: number,
+): MastodonStatusRow[] {
+  const rows: Omit<MastodonStatusRow, "rank">[] = [];
+  for (const status of statuses) {
+    const content = stripHtml(status.content).slice(0, 500);
+    if (!content) continue;
+    const account = status.account ?? {};
+    const handle = cleanString(account.acct);
+    rows.push({
+      author: cleanString(account.display_name) || handle,
+      handle: handle ? `@${handle}` : "",
+      content,
+      reblogs: numberValue(status.reblogs_count),
+      favorites: numberValue(status.favourites_count),
+      replies: numberValue(status.replies_count),
+      url: cleanString(status.url),
+      date: cleanString(status.created_at),
+    });
+  }
+  return rows.slice(0, limit).map((row, index) => ({
+    rank: index + 1,
+    ...row,
+  }));
+}
+
+function parseLimit(value: unknown): number {
+  const limit = Number(value ?? 20);
+  if (!Number.isInteger(limit) || limit < 1 || limit > 40) {
+    throw new Error(
+      `--limit must be an integer between 1 and 40, got ${value}`,
+    );
+  }
+  return limit;
+}
+
+async function fetchMastodonJson(url: string): Promise<unknown> {
+  const response = await fetch(url, {
+    headers: {
+      Accept: "application/json",
+      "User-Agent": USER_AGENT,
+    },
+  });
+  if (!response.ok) {
+    const preview = (await response.text()).slice(0, 200);
+    throw new Error(`Mastodon HTTP ${response.status} from ${url}: ${preview}`);
+  }
+  return response.json() as Promise<unknown>;
+}
+
+function requireAccountId(account: unknown): string {
+  if (!account || typeof account !== "object") {
+    throw new Error("Mastodon account lookup returned a non-object response");
+  }
+  const id = cleanString((account as MastodonAccount).id);
+  if (!id) throw new Error("Mastodon account lookup did not return an id");
+  return id;
+}
+
+cli({
+  site: "mastodon",
+  name: "statuses",
+  description: "Get recent public statuses from a Mastodon account",
+  domain: "mastodon.social",
+  strategy: Strategy.PUBLIC,
+  args: [
+    {
+      name: "account",
+      required: true,
+      positional: true,
+      description: "Account handle, e.g. gargron@mastodon.social",
+    },
+    {
+      name: "instance",
+      type: "str",
+      default: "mastodon.social",
+      description: "Mastodon instance domain used when account omits one",
+    },
+    {
+      name: "limit",
+      type: "int",
+      default: 20,
+      description: "Number of statuses, 1-40",
+    },
+  ],
+  columns: [
+    "rank",
+    "author",
+    "handle",
+    "content",
+    "reblogs",
+    "favorites",
+    "replies",
+    "url",
+    "date",
+  ],
+  socialCapabilities: ["read", "user_content", "reactions"],
+  func: async (_page, kwargs) => {
+    const limit = parseLimit(kwargs.limit);
+    const account = normalizeMastodonAccount(
+      String(kwargs.account ?? ""),
+      String(kwargs.instance ?? "mastodon.social"),
+    );
+    const origin = `https://${account.instance}`;
+    const lookupUrl = new URL("/api/v1/accounts/lookup", origin);
+    lookupUrl.searchParams.set("acct", account.acct);
+    const lookup = await fetchMastodonJson(lookupUrl.toString());
+    const accountId = requireAccountId(lookup);
+    const statusesUrl = new URL(
+      `/api/v1/accounts/${encodeURIComponent(accountId)}/statuses`,
+      origin,
+    );
+    statusesUrl.searchParams.set("limit", String(limit));
+    statusesUrl.searchParams.set("exclude_reblogs", "false");
+    statusesUrl.searchParams.set("exclude_replies", "false");
+    const statuses = await fetchMastodonJson(statusesUrl.toString());
+    if (!Array.isArray(statuses)) {
+      throw new Error(
+        "Mastodon statuses endpoint returned a non-array response",
+      );
+    }
+    return mapMastodonStatusRows(statuses as MastodonStatus[], limit);
+  },
+});