CLI: Add webfinger command using Optique

cspell.json

@@ -58,6 +58,7 @@
     "lume",
     "lumocs",
     "metas",
+    "metavar",
     "microblog",
     "microblogging",
     "Minhee",
@@ -69,6 +70,7 @@
     "multitenancy",
     "Nexkey",
     "nodeinfo",
+    "optique",
     "phensley",
     "Pico",
     "Pixelfed",
@@ -105,6 +107,7 @@
     "unfollows",
     "urlpattern",
     "uuidv7",
+    "valueparser",
     "Vinxi",
     "vitepress",
     "vtsls",

packages/cli/src/mod.ts

@@ -1,11 +1,11 @@
 import { or } from "@optique/core";
 import { run } from "@optique/run";
-import { lookupCommand, runLookup } from "./lookup.ts";
-import { runWebFinger, webFingerCommand } from "./webfinger.ts";
-import { initCommand, runInit } from "./init.ts";
 import { inboxCommand, runInbox } from "./inbox.ts";
+import { initCommand, runInit } from "./init.ts";
+import { lookupCommand, runLookup } from "./lookup.ts";
 import { nodeInfoCommand, runNodeInfo } from "./nodeinfo.ts";
 import { runTunnel, tunnelCommand } from "./tunnel.ts";
+import { runWebFinger, webFingerCommand } from "./webfinger.ts";
 
 const command = or(
   initCommand,
@@ -28,7 +28,7 @@ async function main() {
     await runLookup(result);
   }
   if (result.command === "webfinger") {
-    runWebFinger(result);
+    await runWebFinger(result);
   }
   if (result.command === "inbox") {
     runInbox(result);

packages/cli/src/webfinger.test.ts

@@ -0,0 +1,85 @@
+import { lookupWebFinger } from "@fedify/fedify/webfinger";
+import { run } from "@optique/run";
+import { assertEquals, assertStrictEquals, assertThrows } from "@std/assert";
+import test from "node:test";
+import { convertHandleToUrl, webFingerCommand } from "./webfinger.ts";
+
+const COMMAND = "webfinger";
+const RESOURCES = ["@hongminhee@hackers.pub", "@fedify@hollo.social"];
+const USER_AGENT = "MyUserAgent/1.0";
+const ALIASES = [
+  "https://hackers.pub/ap/actors/019382d3-63d7-7cf7-86e8-91e2551c306c",
+  "https://hollo.social/@fedify",
+];
+
+test("webFingerCommand", () => {
+  // Resources only
+  const argsWithResourcesOnly = [COMMAND, ...RESOURCES];
+  assertEquals(
+    run(webFingerCommand, {
+      args: argsWithResourcesOnly,
+    }),
+    {
+      debug: false,
+      command: COMMAND,
+      resources: RESOURCES,
+      allowPrivateAddresses: undefined,
+      maxRedirection: 5,
+      userAgent: undefined,
+    },
+  );
+  // With options
+  const maxRedirection = 10;
+  assertStrictEquals(
+    run(webFingerCommand, {
+      args: [
+        ...argsWithResourcesOnly,
+        "-u",
+        USER_AGENT,
+        "--max-redirection",
+        String(maxRedirection),
+        "--allow-private-addresses",
+      ],
+    }),
+    {
+      command: COMMAND,
+      resources: RESOURCES,
+      allowPrivateAddresses: true,
+      maxRedirection,
+      userAgent: USER_AGENT,
+    },
+  );
+  // Wrong option
+  assertThrows(() =>
+    run(
+      webFingerCommand,
+      {
+        args: [
+          ...argsWithResourcesOnly,
+          "-Q",
+        ],
+      },
+    )
+  );
+  // Wrong option value
+  assertThrows(() =>
+    run(
+      webFingerCommand,
+      {
+        args: [
+          ...argsWithResourcesOnly,
+          "--max-redirection",
+          "-10",
+        ],
+      },
+    )
+  );
+});
+
+test("Lookup webfinger", async () => {
+  const aliases = (await Array.fromAsync(
+    RESOURCES.map(convertHandleToUrl),
+    (h) => lookupWebFinger(h),
+  )).map((w) => w?.aliases?.[0]);
+  assertStrictEquals(aliases, ALIASES);
+});

packages/cli/src/webfinger.ts

@@ -1,15 +1,52 @@
+import { type ResourceDescriptor, toAcctUrl } from "@fedify/fedify";
+import {
+  lookupWebFinger,
+  type LookupWebFingerOptions,
+} from "@fedify/fedify/webfinger";
+import { getLogger } from "@logtape/logtape";
 import {
   argument,
   command,
   constant,
+  flag,
   type InferValue,
+  integer,
   merge,
   message,
   multiple,
   object,
+  option,
+  optional,
   string,
+  withDefault,
 } from "@optique/core";
+import ora from "ora";
 import { debugOption } from "./globals.ts";
+import { formatObject } from "./utils.ts";
+
+const _logger = getLogger(["fedify", "cli", "webfinger"]);
+
+const userAgent = optional(option(
+  "-u",
+  "--user-agent",
+  string({ metavar: "USER_AGENT" }),
+  {
+    description: message`The custom User-Agent header value.`,
+  },
+));
+
+const allowPrivateAddresses = optional(flag("-p", "--allow-private-address", {
+  description: message`Allow private IP addresses in the URL.`,
+}));
+
+const maxRedirection = withDefault(
+  option(
+    "--max-redirection",
+    integer({ min: 0 }),
+    { description: message`Maximum number of redirections to follow.` },
+  ),
+  5,
+);
 
 export const webFingerCommand = command(
   "webfinger",
@@ -19,16 +56,121 @@ export const webFingerCommand = command(
       resources: multiple(argument(string({ metavar: "RESOURCE" }), {
         description: message`WebFinger resource(s) to look up.`,
       })),
+      userAgent,
+      allowPrivateAddresses,
+      maxRedirection,
     }),
     debugOption,
   ),
   {
-    description: message`Look up WebFinger resources.`,
+    description:
+      message`Look up WebFinger resources. The argument can be multiple.`,
   },
 );
 
-export function runWebFinger(
-  command: InferValue<typeof webFingerCommand>,
+export async function runWebFinger(
+  { command: _, resources, ...options }: InferValue<typeof webFingerCommand>,
 ) {
-  console.debug(command);
+  await Array.fromAsync(
+    resources.map((resource) => ({ resource, ...options })),
+    spinnerWrapper(lookupSingleWebFinger),
+  );
+}
+
+async function lookupSingleWebFinger<
+  T extends LookupWebFingerOptions & { resource: string },
+>({ resource, ...options }: T): Promise<ResourceDescriptor> {
+  const url = convertUrlIfHandle(resource);
+  const webFinger = await lookupWebFinger(url, options) ??
+    new NotFoundError(resource).throw();
+  return webFinger;
+}
+
+function spinnerWrapper<F extends typeof lookupSingleWebFinger>(
+  func: (...args: Parameters<F>) => ReturnType<F>,
+) {
+  return async (...args: Parameters<F>) => {
+    const spinner = ora({
+      text: `Looking up WebFinger for ${args[0]}`,
+      discardStdin: false,
+    }).start();
+    try {
+      const result = await func(...args);
+      spinner.succeed(`WebFinger found for ${args[0]}:`);
+      console.log(formatObject(result, undefined, true));
+    } catch (error) {
+      spinner.fail(getErrorMessage(args[0].resource, error));
+    }
+  };
+}
+
+const getErrorMessage = (resource: string, error: unknown): string =>
+  error instanceof InvalidHandleError
+    ? `Invalid handle format: ${error.handle}`
+    : error instanceof NotFoundError
+    ? `Resource not found: ${error.resource}`
+    : error instanceof Error
+    ? `Error looking up WebFinger for ${resource}: ${error.message}`
+    : `Error looking up WebFinger for ${resource}: ${error}`;
+
+/**
+ * Converts a handle or URL to a URL object.
+ * If the input is a valid URL, it returns the URL object.
+ * If the input is a handle in the format `@username@domain`, it converts it to a URL.
+ * @param handleOrUrl The handle or URL to convert.
+ * @returns A URL object representing the handle or URL.
+ */
+function convertUrlIfHandle(handleOrUrl: string): URL {
+  try {
+    return new URL(handleOrUrl); // Try to convert the input to a URL
+  } catch {
+    return convertHandleToUrl(handleOrUrl); // If it fails, treat it as a handle
+  }
+}
+
+/**
+ * Custom error class for invalid handle formats.
+ * @param {string} handle The invalid handle that caused the error.
+ * @extends {Error}
+ */
+class InvalidHandleError extends Error {
+  constructor(public handle: string) {
+    super(`Invalid handle format: ${handle}`);
+    this.name = "InvalidHandleError";
+  }
+  throw(): never {
+    throw this;
+  }
+}
+
+/**
+ * Custom error class for not found resources.
+ * @param {string} resource The resource that was not found.
+ * @extends {Error}
+ */
+class NotFoundError extends Error {
+  constructor(public resource: string) {
+    super(`Resource not found: ${resource}`);
+    this.name = "NotFoundError";
+  }
+  throw(): never {
+    throw this;
+  }
+}
+
+/**
+ * Converts a handle in the format `@username@domain` to a URL.
+ * The resulting URL will be in the format `https://domain/@username`.
+ * @param handle The handle to convert, in the format `@username@domain`.
+ * @returns A URL object representing the handle.
+ * @throws {Error} If the handle format is invalid.
+ * @example
+ * ```ts
+ * const url = convertHandleToUrl("@username@domain.com");
+ * console.log(url.toString()); // "https://domain.com/@username"
+ * ```
+ */
+export function convertHandleToUrl(handle: string): URL {
+  return toAcctUrl(handle) ?? // Convert the handle to a URL
+    new InvalidHandleError(handle).throw(); // or throw an error if invalid
 }