@fedify/cli 2.0.0-pr.479.1922 → 2.0.0

package/src/tempserver.ts

@@ -1,87 +0,0 @@
-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.test.ts

@@ -1,157 +0,0 @@
-import type { Tunnel, TunnelOptions } from "@hongminhee/localtunnel";
-import { run } from "@optique/run";
-import { deepEqual, rejects } from "node:assert/strict";
-import test from "node:test";
-import type { Ora } from "ora";
-import { runTunnel, tunnelCommand } from "./tunnel.ts";
-
-test("tunnel command structure", () => {
-  const testCommandWithOptions = run(tunnelCommand, {
-    args: ["tunnel", "3001", "-s", "pinggy.io", "-d"],
-  });
-  const testCommandWithoutOptions = run(tunnelCommand, {
-    args: ["tunnel", "3000"],
-  });
-
-  deepEqual(testCommandWithOptions.command, "tunnel");
-  deepEqual(testCommandWithOptions.port, 3001);
-  deepEqual(testCommandWithOptions.service, "pinggy.io");
-  deepEqual(testCommandWithOptions.debug, true);
-
-  deepEqual(testCommandWithoutOptions.port, 3000);
-  deepEqual(testCommandWithoutOptions.service, undefined);
-  deepEqual(testCommandWithoutOptions.debug, false);
-});
-
-test("tunnel successfully creates and manages tunnel", async () => {
-  const mockCommand = {
-    command: "tunnel" as const,
-    port: 3001,
-    service: "pinggy.io" as const,
-    debug: true,
-  };
-
-  const mockTunnel: Tunnel = {
-    url: new URL("https://droar-218-152-125-59.a.free.pinggy.link/"),
-    localPort: 3001,
-    pid: 123,
-    close: () => Promise.resolve(),
-  };
-
-  let openTunnelCalled = false;
-  let openTunnelPort;
-  let openTunnelService;
-  let spinnerCalled = false;
-  let openTunnelSucceed = false;
-  let openTunnelFailed = false;
-  let spinnerMsg;
-
-  const mockDeps = {
-    openTunnel: (args: TunnelOptions) => {
-      openTunnelCalled = true;
-      openTunnelPort = args.port;
-      openTunnelService = args.service;
-      return Promise.resolve(mockTunnel);
-    },
-    ora: () =>
-      ({
-        start() {
-          spinnerCalled = true;
-          return this;
-        },
-        fail(msg: string) {
-          openTunnelFailed = true;
-          spinnerMsg = msg;
-          return this;
-        },
-        succeed(msg: string) {
-          openTunnelSucceed = true;
-          spinnerMsg = msg;
-          return this;
-        },
-      }) as unknown as Ora,
-    exit: (): never => {
-      throw new Error();
-    },
-  };
-
-  try {
-    await runTunnel(mockCommand, mockDeps);
-  } finally {
-    deepEqual(openTunnelCalled, true);
-    deepEqual(openTunnelPort, 3001);
-    deepEqual(openTunnelService, "pinggy.io");
-    deepEqual(openTunnelSucceed, true);
-    deepEqual(openTunnelFailed, false);
-    deepEqual(spinnerCalled, true);
-    deepEqual(
-      spinnerMsg,
-      `Your local server at ${mockTunnel.localPort} is now publicly accessible:\n`,
-    );
-  }
-});
-
-test("tunnel fails to create a secure tunnel and handles error", async () => {
-  const mockCommand = {
-    command: "tunnel" as const,
-    port: 3001,
-    service: undefined,
-    debug: false,
-  };
-
-  let openTunnelCalled = false;
-  let openTunnelPort;
-  let openTunnelService;
-  let spinnerCalled = false;
-  let openTunnelSucceed = false;
-  let openTunnelFailed = false;
-  let spinnerMsg;
-
-  const mockDeps = {
-    openTunnel: (args: TunnelOptions) => {
-      openTunnelCalled = true;
-      openTunnelPort = args.port;
-      openTunnelService = args.service;
-      return Promise.reject();
-    },
-    ora: () =>
-      ({
-        start() {
-          spinnerCalled = true;
-          return this;
-        },
-        fail(msg: string) {
-          openTunnelFailed = true;
-          spinnerMsg = msg;
-          return this;
-        },
-        succeed(msg: string) {
-          openTunnelSucceed = true;
-          spinnerMsg = msg;
-          return this;
-        },
-      }) as unknown as Ora,
-    exit: (): never => {
-      throw new Error("Process exit called");
-    },
-  };
-
-  try {
-    await rejects(
-      () => runTunnel(mockCommand, mockDeps),
-      Error,
-      "Process exit called",
-    );
-  } finally {
-    deepEqual(openTunnelCalled, true);
-    deepEqual(openTunnelPort, 3001);
-    deepEqual(openTunnelService, undefined);
-    deepEqual(openTunnelSucceed, false);
-    deepEqual(openTunnelFailed, true);
-    deepEqual(spinnerCalled, true);
-    deepEqual(
-      spinnerMsg,
-      "Failed to create a secure tunnel.",
-    );
-  }
-});

package/src/tunnel.ts

@@ -1,94 +0,0 @@
-import { openTunnel, type Tunnel } from "@hongminhee/localtunnel";
-import {
-  argument,
-  command,
-  constant,
-  type InferValue,
-  integer,
-  merge,
-  message,
-  object,
-  option,
-  optional,
-} from "@optique/core";
-import { choice } from "@optique/core/valueparser";
-import { print, printError } from "@optique/run";
-import process from "node:process";
-import ora from "ora";
-import { configureLogging, debugOption } from "./globals.ts";
-
-export const tunnelCommand = command(
-  "tunnel",
-  merge(
-    "Tunnel options",
-    object({
-      command: constant("tunnel"),
-    }),
-    object({
-      port: argument(integer({ metavar: "PORT", min: 0, max: 65535 }), {
-        description: message`The local port number to expose.`,
-      }),
-      service: optional(
-        option(
-          "-s",
-          "--service",
-          choice(["localhost.run", "serveo.net", "pinggy.io"], {
-            metavar: "SERVICE",
-          }),
-          { description: message`The tunneling service to use.` },
-        ),
-      ),
-    }),
-    debugOption,
-  ),
-  {
-    brief:
-      message`Expose a local HTTP server to the public internet using a secure tunnel.`,
-    description:
-      message`Expose a local HTTP server to the public internet using a secure tunnel.
-
-Note that the HTTP requests through the tunnel have X-Forwarded-* headers.`,
-  },
-);
-
-export async function runTunnel(
-  command: InferValue<typeof tunnelCommand>,
-  deps: {
-    openTunnel: typeof openTunnel;
-    ora: typeof ora;
-    exit: typeof process.exit;
-  } = {
-    openTunnel,
-    ora,
-    exit: process.exit,
-  },
-) {
-  if (command.debug) {
-    await configureLogging();
-  }
-  const spinner = deps.ora({
-    text: "Creating a secure tunnel...",
-    discardStdin: false,
-  }).start();
-  let tunnel: Tunnel;
-  try {
-    tunnel = await deps.openTunnel({
-      port: command.port,
-      service: command.service,
-    });
-  } catch (error) {
-    if (command.debug) {
-      printError(message`${String(error)}`);
-    }
-    spinner.fail("Failed to create a secure tunnel.");
-    deps.exit(1);
-  }
-  spinner.succeed(
-    `Your local server at ${command.port} is now publicly accessible:\n`,
-  );
-  print(message`${tunnel.url.href}`);
-  print(message`\nPress ^C to close the tunnel.`);
-  process.on("SIGINT", async () => {
-    await tunnel.close();
-  });
-}

package/src/utils.ts

@@ -1,254 +0,0 @@
-import { isObject } from "@fxts/core";
-import { message } from "@optique/core";
-import { print, printError } from "@optique/run";
-import { Chalk } from "chalk";
-import { highlight } from "cli-highlight";
-import { flow, 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 class CommandError extends Error {
-  public commandLine: string;
-  constructor(
-    message: string,
-    public stdout: string,
-    public stderr: string,
-    public code: number,
-    public command: string[],
-  ) {
-    super(message);
-    this.name = "CommandError";
-    this.commandLine = command.join(" ");
-  }
-}
-
-export const runSubCommand = async <Opt extends Parameters<typeof spawn>[2]>(
-  command: string[],
-  options: Opt,
-): Promise<{
-  stdout: string;
-  stderr: string;
-}> => {
-  const commands = // split by "&&"
-    command.reduce<string[][]>((acc, cur) => {
-      if (cur === "&&") {
-        acc.push([]);
-      } else {
-        if (acc.length === 0) acc.push([]);
-        acc[acc.length - 1].push(cur);
-      }
-      return acc;
-    }, []);
-
-  const results = { stdout: "", stderr: "" };
-
-  for (const cmd of commands) {
-    try {
-      const result = await runSingularCommand(cmd, options);
-      results.stdout += (results.stdout ? "\n" : "") + result.stdout;
-      results.stderr += (results.stderr ? "\n" : "") + result.stderr;
-    } catch (e) {
-      if (e instanceof CommandError) {
-        results.stdout += (results.stdout ? "\n" : "") + e.stdout;
-        results.stderr += (results.stderr ? "\n" : "") + e.stderr;
-      }
-      throw e;
-    }
-  }
-  return results;
-};
-
-const runSingularCommand = (
-  command: string[],
-  options: Parameters<typeof spawn>[2],
-) =>
-  new Promise<{
-    stdout: string;
-    stderr: string;
-  }>((resolve, reject) => {
-    let stdout = "";
-    let stderr = "";
-    const child = spawn(command[0], command.slice(1), options);
-
-    child.stdout?.on("data", (data) => {
-      stdout += data.toString();
-    });
-    child.stderr?.on("data", (data) => {
-      stderr += data.toString();
-    });
-
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve({
-          stdout: stdout.trim(),
-          stderr: stderr.trim(),
-        });
-      } else {
-        reject(
-          new CommandError(
-            `Command exited with code ${code ?? "unknown"}`,
-            stdout.trim(),
-            stderr.trim(),
-            code ?? -1,
-            command,
-          ),
-        );
-      }
-    });
-
-    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 replaceAll = (
-  pattern: string | RegExp,
-  replacement: string | ((substring: string, ...args: unknown[]) => string),
-) =>
-(text: string): string => text.replaceAll(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);
-
-/**
- * Generic type to represent the types of the items in iterables.
- */
-export type ItersItems<T extends Iterable<unknown>[]> = T extends [] ? []
-  : T extends [infer Head, ...infer Tail]
-    ? Head extends Iterable<infer Item>
-      ? Tail extends Iterable<unknown>[] ? [Item, ...ItersItems<Tail>]
-      : [Item]
-    : never
-  : never;
-
-/**
- * ```haskell
- * product::[[a], [b], ...] -> [[a, b, ...]]
- * ```
- *
- * Cartesian product of the input iterables.
- * Inspired by Python's `itertools.product`.
- *
- * @param {...Iterable<unknown>} iters - The input iterables to compute the Cartesian product.
- * @returns {Generator<ItersItems<T>>} A generator that yields arrays containing one element from each iterable.
- *
- * @example
- * ```ts
- * const iter1 = [1, 2];
- * const iter2 = ['a', 'b'];
- * const iter3 = [true, false];
- * const productIter = product(iter1, iter2, iter3);
- * console.log(Array.from(productIter)); // Output: [[1, 'a', true], [1, 'a', false], [
- */
-export function* product<T extends Iterable<unknown>[]>(
-  ...[head, ...tail]: T
-): Generator<ItersItems<T>> {
-  if (!head) yield [] as ItersItems<T>;
-  else {
-    for (const x of head) {
-      for (const xs of product(...tail)) yield [x, ...xs] as ItersItems<T>;
-    }
-  }
-}
-
-export type GeneratedType<T extends Generator> = T extends
-  Generator<unknown, infer R, unknown> ? R : never;
-
-type PrintMessage = (...args: Parameters<typeof message>) => void;
-export const printMessage: PrintMessage = flow(message, print);
-export const printErrorMessage: PrintMessage = flow(message, printError);

package/src/webfinger/action.ts

@@ -1,50 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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.`,
-        }),
-        { min: 1 },
-      ),
-      userAgent,
-      allowPrivateAddresses,
-      maxRedirection,
-    }),
-    debugOption,
-  ),
-  {
-    brief: message`Look up WebFinger resources.`,
-    description: message`Look up WebFinger resources.
-
-The argument can be multiple.`,
-  },
-);
-
-export type WebFingerCommand = InferValue<typeof webFingerCommand>;