@fedify/cli 1.8.11 → 2.0.0-dev.1757

package/src/tempserver.ts

@@ -0,0 +1,87 @@
+import { openTunnel } from "@hongminhee/localtunnel";
+import { getLogger } from "@logtape/logtape";
+import { serve } from "srvx";
+
+const logger = getLogger(["fedify", "cli", "tempserver"]);
+
+export type SpawnTemporaryServerOptions = {
+  noTunnel?: boolean;
+};
+
+export type TemporaryServer = {
+  url: URL;
+  close(): Promise<void>;
+};
+
+export async function spawnTemporaryServer(
+  fetch: (request: Request) => Promise<Response> | Response,
+  options: SpawnTemporaryServerOptions = {},
+): Promise<TemporaryServer> {
+  if (options.noTunnel) {
+    const server = serve({
+      port: 0,
+      hostname: "::",
+      fetch: fetch,
+    });
+    await server.ready();
+    const url = new URL(server.url!);
+    const port = url.port;
+    logger.debug("Temporary server is listening on port {port}.", {
+      port: port,
+    });
+
+    return {
+      url: new URL(`http://localhost:${port}`),
+      async close() {
+        await server.close();
+      },
+    };
+  }
+
+  const server = serve({
+    fetch: (request) => {
+      const url = new URL(request.url);
+      url.protocol = "https:";
+      request = new Request(url, {
+        method: request.method,
+        headers: request.headers,
+        body: request.method === "GET" || request.method === "HEAD"
+          ? null
+          : request.body,
+        referrer: request.referrer,
+        referrerPolicy: request.referrerPolicy,
+        mode: request.mode,
+        credentials: request.credentials,
+        cache: request.cache,
+        redirect: request.redirect,
+        integrity: request.integrity,
+        keepalive: request.keepalive,
+        signal: request.signal,
+      });
+
+      return new Response();
+    },
+    port: 0,
+    hostname: "::",
+  });
+
+  await server.ready();
+
+  const url = new URL(server.url!);
+  const port = url.port;
+
+  logger.debug("Temporary server is listening on port {port}.", { port });
+  const tun = await openTunnel({ port: parseInt(port) });
+  logger.debug(
+    "Temporary server is tunneled to {url}.",
+    { url: tun.url.href },
+  );
+
+  return {
+    url: tun.url,
+    async close() {
+      await server.close();
+      await tun.close();
+    },
+  };
+}

package/src/tunnel.ts

@@ -0,0 +1,32 @@
+import {
+  argument,
+  command,
+  constant,
+  type InferValue,
+  integer,
+  merge,
+  message,
+  object,
+} from "@optique/core";
+import { debugOption } from "./globals.ts";
+
+export const tunnelCommand = command(
+  "tunnel",
+  merge(
+    object({
+      command: constant("tunnel"),
+      port: argument(integer({ metavar: "PORT", min: 0, max: 65_535 })),
+    }),
+    debugOption,
+  ),
+  {
+    description:
+      message`Expose a local HTTP server to the public internet using a secure tunnel.`,
+  },
+);
+
+export function runTunnel(
+  command: InferValue<typeof tunnelCommand>,
+) {
+  console.debug(command);
+}

package/src/utils.ts

@@ -0,0 +1,136 @@
+import { isObject } from "@fxts/core";
+import { Chalk } from "chalk";
+import { highlight } from "cli-highlight";
+import { toMerged } from "es-toolkit";
+import { spawn } from "node:child_process";
+import { writeFile } from "node:fs/promises";
+import process from "node:process";
+import util from "node:util";
+
+export const colorEnabled: boolean = process.stdout.isTTY &&
+  !("NO_COLOR" in process.env && process.env.NO_COLOR !== "");
+
+export const colors = new Chalk(colorEnabled ? {} : { level: 0 });
+
+export function formatObject(
+  obj: unknown,
+  colors?: boolean,
+  json?: boolean,
+): string {
+  const enableColors = colors ?? colorEnabled;
+  if (!json) return util.inspect(obj, { colors: enableColors });
+  const formatted = JSON.stringify(obj, null, 2);
+  if (enableColors) {
+    return highlight(formatted, { language: "json" });
+  }
+  return formatted;
+}
+
+export const isPromise = <T>(a: unknown): a is Promise<T> =>
+  a instanceof Promise;
+
+export function set<K extends PropertyKey, T extends object, S>(
+  key: K,
+  f: (value: T) => S,
+): (
+  obj: T,
+) => S extends Promise<infer U> ? Promise<T & { [P in K]: Awaited<U> }>
+  : T & { [P in K]: S } {
+  return ((obj) => {
+    const result = f(obj);
+    if (isPromise<S extends Promise<infer U> ? U : never>(result)) {
+      return result.then((value) => ({ ...obj, [key]: value })) as S extends
+        Promise<infer U> ? Promise<
+          T & { [P in K]: Awaited<U> }
+        >
+        : never;
+    }
+    return ({ ...obj, [key]: result }) as S extends Promise<infer _> ? never
+      : T & { [P in K]: S };
+  });
+}
+
+export const merge =
+  (source: Parameters<typeof toMerged>[1] = {}) =>
+  (target: Parameters<typeof toMerged>[0] = {}) => toMerged(target, source);
+
+export const isNotFoundError = (e: unknown): e is { code: "ENOENT" } =>
+  isObject(e) &&
+  "code" in e &&
+  e.code === "ENOENT";
+
+export const runSubCommand = <Opt extends Parameters<typeof spawn>[2]>(
+  command: string[],
+  options: Opt,
+): Promise<{
+  stdout: string;
+  stderr: string;
+}> =>
+  new Promise((resolve, reject) => {
+    const child = spawn(command[0], command.slice(1), options);
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+
+    child.on("close", () => {
+      resolve({
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+      });
+    });
+
+    child.on("error", (error) => {
+      reject(error);
+    });
+  });
+
+export type RequiredNotNull<T> = {
+  [P in keyof T]: NonNullable<T[P]>;
+};
+
+export const getCwd = () => process.cwd();
+
+export const replace = (
+  pattern: string | RegExp,
+  replacement: string | ((substring: string, ...args: unknown[]) => string),
+) =>
+(text: string): string => text.replace(pattern, replacement as string);
+
+export const getOsType = () => process.platform;
+
+export async function writeTextFile(
+  path: string,
+  content: string,
+): Promise<void> {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(content);
+  return await writeFile(path, data);
+}
+
+export const resolveProps = async <T extends object>(obj: T): Promise<
+  { [P in keyof T]: Awaited<T[P]> }
+> =>
+  Object.fromEntries(
+    await Array.fromAsync(
+      Object.entries(obj),
+      async ([k, v]) => [k, await v],
+    ),
+  ) as Promise<{ [P in keyof T]: Awaited<T[P]> }>;
+
+export const formatJson = (obj: unknown) => JSON.stringify(obj, null, 2) + "\n";
+
+export const notEmpty = <T extends string | { length: number }>(s: T) =>
+  s.length > 0;
+
+export const notEmptyObj = <T extends Record<PropertyKey, never> | object>(
+  obj: T,
+): obj is Exclude<T, Record<PropertyKey, never>> => Object.keys(obj).length > 0;
+
+export const exit = (code: number) => process.exit(code);

package/src/webfinger/action.ts

@@ -0,0 +1,50 @@
+import type { ResourceDescriptor } from "@fedify/fedify";
+import {
+  lookupWebFinger,
+  type LookupWebFingerOptions,
+} from "@fedify/fedify/webfinger";
+import { formatMessage, message } from "@optique/core/message";
+import { print } from "@optique/run";
+import ora from "ora";
+import { formatObject } from "../utils.ts";
+import type { WebFingerCommand } from "./command.ts";
+import { getErrorMessage, NotFoundError } from "./error.ts";
+import { convertUrlIfHandle } from "./lib.ts";
+
+export default async function runWebFinger(
+  { command: _, resources, ...options }: WebFingerCommand,
+) {
+  await Array.fromAsync(
+    resources.map((resource) => ({ resource, ...options })),
+    spinnerWrapper(lookupSingleWebFinger),
+  );
+}
+
+export 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(
+        formatMessage(message`WebFinger found for ${args[0].resource}:`),
+      );
+      print([{ type: "text", text: formatObject(result) }]);
+    } catch (error) {
+      spinner.fail(formatMessage(getErrorMessage(args[0].resource, error)));
+    }
+  };
+}

package/src/webfinger/command.ts

@@ -0,0 +1,59 @@
+import {
+  argument,
+  command,
+  constant,
+  flag,
+  type InferValue,
+  integer,
+  merge,
+  message,
+  multiple,
+  object,
+  option,
+  optional,
+  string,
+  withDefault,
+} from "@optique/core";
+import { debugOption } from "../globals.ts";
+
+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",
+  merge(
+    object({
+      command: constant("webfinger"),
+      resources: multiple(argument(string({ metavar: "RESOURCE" }), {
+        description: message`WebFinger resource(s) to look up.`,
+      })),
+      userAgent,
+      allowPrivateAddresses,
+      maxRedirection,
+    }),
+    debugOption,
+  ),
+  {
+    description:
+      message`Look up WebFinger resources. The argument can be multiple.`,
+  },
+);
+
+export type WebFingerCommand = InferValue<typeof webFingerCommand>;

package/src/webfinger/error.ts

@@ -0,0 +1,47 @@
+import { type Message, message } from "@optique/core";
+
+/**
+ * Generates a user-friendly error message based on the type of error
+ * encountered during WebFinger lookup.
+ * @param {string} resource The resource being looked up.
+ * @param {unknown} error The error encountered.
+ * @returns {string} A descriptive error message.
+ */
+export const getErrorMessage = (resource: string, error: unknown): Message =>
+  error instanceof InvalidHandleError
+    ? message`Invalid handle format: ${error.handle}`
+    : error instanceof NotFoundError
+    ? message`Resource not found: ${error.resource}`
+    : error instanceof Error
+    ? message`Failed to look up WebFinger for ${resource}: ${error.message}`
+    : message`Failed to look up WebFinger for ${resource}: ${String(error)}`;
+
+/**
+ * Custom error class for invalid handle formats.
+ * @param {string} handle The invalid handle that caused the error.
+ * @extends {Error}
+ */
+export 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}
+ */
+export class NotFoundError extends Error {
+  constructor(public resource: string) {
+    super(`Resource not found: ${resource}`);
+    this.name = "NotFoundError";
+  }
+  throw(): never {
+    throw this;
+  }
+}

package/src/webfinger/lib.ts

@@ -0,0 +1,37 @@
+import { toAcctUrl } from "@fedify/fedify";
+import { getLogger } from "@logtape/logtape";
+import { InvalidHandleError } from "./error.ts";
+
+export const logger = getLogger(["fedify", "cli", "webfinger"]);
+
+/**
+ * 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.
+ */
+export 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
+  }
+}
+
+/**
+ * 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
+}

package/src/webfinger/mod.test.ts

@@ -0,0 +1,79 @@
+import { parse } from "@optique/core/parser";
+import assert from "node:assert/strict";
+import test from "node:test";
+import { lookupSingleWebFinger } from "./action.ts";
+import { webFingerCommand } from "./command.ts";
+
+const COMMAND = "webfinger";
+const USER_AGENT = "MyUserAgent/1.0";
+const RESOURCES = [
+  "@hongminhee@hackers.pub",
+  "@fedify@hollo.social",
+];
+const ALIASES = [
+  "https://hackers.pub/ap/actors/019382d3-63d7-7cf7-86e8-91e2551c306c",
+  "https://hollo.social/@fedify",
+];
+
+test("Test webFingerCommand", () => {
+  // Resources only
+  const argsWithResourcesOnly = [COMMAND, ...RESOURCES];
+  assert.deepEqual(
+    parse(webFingerCommand, argsWithResourcesOnly),
+    {
+      success: true,
+      value: {
+        debug: false,
+        command: COMMAND,
+        resources: RESOURCES,
+        allowPrivateAddresses: undefined,
+        maxRedirection: 5,
+        userAgent: undefined,
+      },
+    },
+  );
+  // With options
+  const maxRedirection = 10;
+  assert.deepEqual(
+    parse(webFingerCommand, [
+      ...argsWithResourcesOnly,
+      "-d",
+      "-u",
+      USER_AGENT,
+      "--max-redirection",
+      String(maxRedirection),
+      "--allow-private-address",
+    ]),
+    {
+      success: true,
+      value: {
+        debug: true,
+        command: COMMAND,
+        resources: RESOURCES,
+        allowPrivateAddresses: true,
+        maxRedirection,
+        userAgent: USER_AGENT,
+      },
+    },
+  );
+  // Wrong option
+  const wrongOptionResult = parse(webFingerCommand, [
+    ...argsWithResourcesOnly,
+    "-Q",
+  ]);
+  assert.ok(!wrongOptionResult.success);
+  // Wrong option value
+  const wrongOptionValueResult = parse(
+    webFingerCommand,
+    [...argsWithResourcesOnly, "--max-redirection", "-10"],
+  );
+  assert.ok(!wrongOptionValueResult.success);
+});
+
+test("Test lookupSingleWebFinger", async () => {
+  const aliases = (await Array.fromAsync(
+    RESOURCES,
+    (resource) => lookupSingleWebFinger({ resource }),
+  )).map((w) => w?.aliases?.[0]);
+  assert.deepEqual(aliases, ALIASES);
+});

package/src/webfinger/mod.ts

@@ -0,0 +1,2 @@
+export { default as runWebFinger } from "./action.ts";
+export { webFingerCommand } from "./command.ts";

package/tsdown.config.ts

@@ -0,0 +1,24 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: ["src/mod.ts", "src/kv.bun.ts", "src/kv.node.ts"],
+  platform: "node",
+  unbundle: true,
+  inputOptions: {
+    onwarn(warning, defaultHandler) {
+      if (
+        warning.code === "UNRESOLVED_IMPORT" &&
+        ["#kv", "bun:sqlite"].includes(warning.exporter ?? "")
+      ) {
+        return;
+      }
+      defaultHandler(warning);
+    },
+  },
+  outputOptions(outputOptions) {
+    outputOptions.intro = `
+      import { Temporal } from "@js-temporal/polyfill";
+    `;
+    return outputOptions;
+  },
+});