@fedify/cli 1.8.11 → 2.0.0-dev.1757

package/src/inbox.tsx

@@ -0,0 +1,535 @@
+/** @jsx react-jsx */
+/** @jsxImportSource hono/jsx */
+import {
+  Accept,
+  Activity,
+  type Actor,
+  Application,
+  type Context,
+  createFederation,
+  Delete,
+  Endpoints,
+  Follow,
+  generateCryptoKeyPair,
+  getActorHandle,
+  Image,
+  isActor,
+  lookupObject,
+  MemoryKvStore,
+  PUBLIC_COLLECTION,
+  type Recipient,
+} from "@fedify/fedify";
+import { getLogger } from "@logtape/logtape";
+import {
+  command,
+  constant,
+  type InferValue,
+  merge,
+  message,
+  multiple,
+  object,
+  option,
+  optional,
+  string,
+  withDefault,
+} from "@optique/core";
+import Table from "cli-table3";
+import { type Context as HonoContext, Hono } from "hono";
+import type { BlankEnv, BlankInput } from "hono/types";
+import process from "node:process";
+import ora from "ora";
+import metadata from "../deno.json" with { type: "json" };
+import { getDocumentLoader } from "./docloader.ts";
+import { configureLogging, debugOption } from "./globals.ts";
+import type { ActivityEntry } from "./inbox/entry.ts";
+import { ActivityEntryPage, ActivityListPage } from "./inbox/view.tsx";
+import { recordingSink } from "./log.ts";
+import { tableStyle } from "./table.ts";
+import { spawnTemporaryServer, type TemporaryServer } from "./tempserver.ts";
+import { colors } from "./utils.ts";
+
+/**
+ * Context data for the ephemeral ActivityPub inbox server.
+ *
+ * This interface defines the shape of context data passed to federation
+ * handlers during inbox command execution.
+ */
+interface ContextData {
+  activityIndex: number;
+  actorName: string;
+  actorSummary: string;
+}
+
+const logger = getLogger(["fedify", "cli", "inbox"]);
+
+export const inboxCommand = command(
+  "inbox",
+  merge(
+    object("Inbox options", {
+      command: constant("inbox"),
+      follow: optional(
+        multiple(
+          option("-f", "--follow", string({ metavar: "URI" }), {
+            description:
+              message`Follow the given actor. The argument can be either an actor URI or a handle. Can be specified multiple times.`,
+          }),
+        ),
+      ),
+      acceptFollow: optional(
+        multiple(
+          option("-a", "--accept-follow", string({ metavar: "URI" }), {
+            description:
+              message`Accept follow requests from the given actor. The argument can be either an actor URI or a handle, or a wildcard (*). Can be specified multiple times. If a wildcard is specified, all follow requests will be accepted.`,
+          }),
+        ),
+      ),
+      noTunnel: option(
+        "-T",
+        "--no-tunnel",
+        {
+          description:
+            message`Do not tunnel the ephemeral ActivityPub server to the public Internet.`,
+        },
+      ),
+      actorName: withDefault(
+        option("--actor-name", string({ metavar: "NAME" }), {
+          description: message`Customize the actor display name.`,
+        }),
+        "Fedify Ephemeral Inbox",
+      ),
+      actorSummary: withDefault(
+        option("--actor-summary", string({ metavar: "SUMMARY" }), {
+          description: message`Customize the actor description.`,
+        }),
+        "An ephemeral ActivityPub inbox for testing purposes.",
+      ),
+    }),
+    debugOption,
+  ),
+  {
+    description:
+      message`Spins up an ephemeral server that serves the ActivityPub inbox with an one-time actor, through a short-lived public DNS with HTTPS. You can monitor the incoming activities in real-time.`,
+  },
+);
+
+export async function runInbox(
+  command: InferValue<typeof inboxCommand>,
+) {
+  const fetch = createFetchHandler({
+    actorName: command.actorName,
+    actorSummary: command.actorSummary,
+  });
+  const sendDeleteToPeers = createSendDeleteToPeers({
+    actorName: command.actorName,
+    actorSummary: command.actorSummary,
+  });
+
+  // Enable Debug mode if requested
+  if (command.debug) {
+    await configureLogging();
+  }
+
+  const spinner = ora({
+    text: "Spinning up an ephemeral ActivityPub server...",
+    discardStdin: false,
+  }).start();
+  const server = await spawnTemporaryServer(fetch, {
+    noTunnel: command.noTunnel,
+  });
+  spinner.succeed(
+    `The ephemeral ActivityPub server is up and running: ${
+      colors.green(
+        server.url.href,
+      )
+    }`,
+  );
+  process.on("SIGINT", () => {
+    spinner.stop();
+    const peersCnt = Object.keys(peers).length;
+    spinner.start(
+      `Sending Delete(Application) activities to the ${peersCnt} ${
+        peersCnt === 1 ? "peer" : "peers"
+      }...`,
+    );
+    sendDeleteToPeers(server).then(() => {
+      spinner.text = "Stopping server...";
+      server.close().then(() => {
+        spinner.succeed("Server stopped.");
+        process.exit(0);
+      });
+    });
+  });
+  spinner.start();
+
+  const fedCtx = federation.createContext(server.url, {
+    activityIndex: -1,
+    actorName: command.actorName,
+    actorSummary: command.actorSummary,
+  });
+
+  if (command.acceptFollow != null && command.acceptFollow.length > 0) {
+    acceptFollows.push(...(command.acceptFollow ?? []));
+  }
+  if (command.follow != null && command.follow.length > 0) {
+    spinner.text = "Following actors...";
+    const documentLoader = await fedCtx.getDocumentLoader({
+      identifier: "i",
+    });
+    for (const uri of command.follow) {
+      spinner.text = `Following ${colors.green(uri)}...`;
+      const actor = await lookupObject(uri, { documentLoader });
+      if (!isActor(actor)) {
+        spinner.fail(`Not an actor: ${colors.red(uri)}`);
+        spinner.start();
+        continue;
+      }
+      if (actor.id != null) peers[actor.id?.href] = actor;
+      await fedCtx.sendActivity(
+        { identifier: "i" },
+        actor,
+        new Follow({
+          id: new URL(`#follows/${actor.id?.href}`, fedCtx.getActorUri("i")),
+          actor: fedCtx.getActorUri("i"),
+          object: actor.id,
+        }),
+      );
+      spinner.succeed(`Sent follow request to ${colors.green(uri)}.`);
+      spinner.start();
+    }
+  }
+  spinner.stop();
+  printServerInfo(fedCtx);
+}
+
+const federationDocumentLoader = await getDocumentLoader();
+
+const federation = createFederation<ContextData>({
+  kv: new MemoryKvStore(),
+  documentLoaderFactory: () => {
+    return federationDocumentLoader;
+  },
+});
+
+const time = Temporal.Now.instant();
+let actorKeyPairs: CryptoKeyPair[] | undefined = undefined;
+
+federation
+  .setActorDispatcher("/{identifier}", async (ctx, identifier) => {
+    if (identifier !== "i") return null;
+    return new Application({
+      id: ctx.getActorUri(identifier),
+      preferredUsername: identifier,
+      name: ctx.data.actorName,
+      summary: ctx.data.actorSummary,
+      inbox: ctx.getInboxUri(identifier),
+      endpoints: new Endpoints({
+        sharedInbox: ctx.getInboxUri(),
+      }),
+      followers: ctx.getFollowersUri(identifier),
+      following: ctx.getFollowingUri(identifier),
+      outbox: ctx.getOutboxUri(identifier),
+      manuallyApprovesFollowers: true,
+      published: time,
+      icon: new Image({
+        url: new URL("https://fedify.dev/logo.png"),
+        mediaType: "image/png",
+      }),
+      publicKey: (await ctx.getActorKeyPairs(identifier))[0].cryptographicKey,
+      assertionMethods: (await ctx.getActorKeyPairs(identifier))
+        .map((pair) => pair.multikey),
+      url: ctx.getActorUri(identifier),
+    });
+  })
+  .setKeyPairsDispatcher(async (_ctxData, identifier) => {
+    if (identifier !== "i") return [];
+    if (actorKeyPairs == null) {
+      actorKeyPairs = [
+        await generateCryptoKeyPair("RSASSA-PKCS1-v1_5"),
+        await generateCryptoKeyPair("Ed25519"),
+      ];
+    }
+    return actorKeyPairs;
+  });
+
+const activities: ActivityEntry[] = [];
+
+const acceptFollows: string[] = [];
+
+async function acceptsFollowFrom(actor: Actor): Promise<boolean> {
+  const actorUri = actor.id;
+  let actorHandle: string | undefined = undefined;
+  if (actorUri == null) return false;
+  for (let uri of acceptFollows) {
+    if (uri === "*") return true;
+    if (uri.startsWith("http:") || uri.startsWith("https:")) {
+      uri = new URL(uri).href; // normalize
+      if (uri === actorUri.href) return true;
+    }
+    if (actorHandle == null) actorHandle = await getActorHandle(actor);
+    if (actorHandle === uri) return true;
+  }
+  return false;
+}
+
+const peers: Record<string, Actor> = {};
+
+function createSendDeleteToPeers(
+  actorOptions: { actorName: string; actorSummary: string },
+): (server: TemporaryServer) => Promise<void> {
+  return async function sendDeleteToPeers(
+    server: TemporaryServer,
+  ): Promise<void> {
+    const ctx = federation.createContext(new Request(server.url), {
+      activityIndex: -1,
+      actorName: actorOptions.actorName,
+      actorSummary: actorOptions.actorSummary,
+    });
+
+    const actor = (await ctx.getActor("i"))!;
+    try {
+      await ctx.sendActivity(
+        { identifier: "i" },
+        Object.values(peers),
+        new Delete({
+          id: new URL(`#delete`, actor.id!),
+          actor: actor.id!,
+          to: PUBLIC_COLLECTION,
+          object: actor,
+        }),
+      );
+    } catch (error) {
+      logger.error(
+        "Failed to send Delete(Application) activities to peers:\n{error}",
+        { error },
+      );
+    }
+  };
+}
+
+const followers: Record<string, Actor> = {};
+
+federation
+  .setInboxListeners("/{identifier}/inbox", "/inbox")
+  .setSharedKeyDispatcher((_) => ({ identifier: "i" }))
+  .on(Activity, async (ctx, activity) => {
+    activities[ctx.data.activityIndex].activity = activity;
+    for await (const actor of activity.getActors()) {
+      if (actor.id != null) peers[actor.id.href] = actor;
+    }
+    for await (const actor of activity.getAttributions()) {
+      if (actor.id != null) peers[actor.id.href] = actor;
+    }
+    if (activity instanceof Follow) {
+      if (acceptFollows.length < 1) return;
+      const objectId = activity.objectId;
+      if (objectId == null) return;
+      const parsed = ctx.parseUri(objectId);
+      if (parsed?.type !== "actor" || parsed.identifier !== "i") return;
+      const { identifier } = parsed;
+      const follower = await activity.getActor();
+      if (!isActor(follower)) return;
+      const accepts = await acceptsFollowFrom(follower);
+      if (!accepts || activity.id == null) {
+        logger.debug("Does not accept follow from {actor}.", {
+          actor: follower.id?.href,
+        });
+        return;
+      }
+      logger.debug("Accepting follow from {actor}.", {
+        actor: follower.id?.href,
+      });
+      followers[activity.id.href] = follower;
+      await ctx.sendActivity(
+        { identifier },
+        follower,
+        new Accept({
+          id: new URL(`#accepts/${follower.id?.href}`, ctx.getActorUri("i")),
+          actor: ctx.getActorUri(identifier),
+          object: activity.id,
+        }),
+      );
+    }
+  });
+
+federation
+  .setFollowersDispatcher("/{identifier}/followers", (_ctx, identifier) => {
+    if (identifier !== "i") return null;
+    const items: Recipient[] = [];
+    for (const follower of Object.values(followers)) {
+      if (follower.id == null) continue;
+      items.push(follower);
+    }
+    return { items };
+  })
+  .setCounter((_ctx, identifier) => {
+    if (identifier !== "i") return null;
+    return Object.keys(followers).length;
+  });
+
+federation
+  .setFollowingDispatcher(
+    "/{identifier}/following",
+    (_ctx, _identifier) => null,
+  )
+  .setCounter((_ctx, _identifier) => 0);
+
+federation
+  .setOutboxDispatcher("/{identifier}/outbox", (_ctx, _identifier) => null)
+  .setCounter((_ctx, _identifier) => 0);
+
+federation.setNodeInfoDispatcher("/nodeinfo/2.1", (_ctx) => {
+  return {
+    software: {
+      name: "fedify-cli",
+      version: metadata.version,
+      repository: new URL("https://github.com/fedify-dev/fedify"),
+    },
+    protocols: ["activitypub"],
+    usage: {
+      users: {
+        total: 1,
+        activeMonth: 1,
+        activeHalfyear: 1,
+      },
+      localComments: 0,
+      localPosts: 0,
+    },
+  };
+});
+
+function printServerInfo(fedCtx: Context<ContextData>): void {
+  const table = new Table({
+    chars: tableStyle,
+    style: { head: [], border: [] },
+  });
+
+  table.push(
+    { "Actor handle:": colors.green(`i@${fedCtx.getActorUri("i").host}`) },
+    { "Actor URI:": colors.green(fedCtx.getActorUri("i").href) },
+    { "Actor inbox:": colors.green(fedCtx.getInboxUri("i").href) },
+    { "Shared inbox:": colors.green(fedCtx.getInboxUri().href) },
+  );
+
+  console.log(table.toString());
+}
+
+async function printActivityEntry(
+  idx: number,
+  entry: ActivityEntry,
+): Promise<void> {
+  const request = entry.request.clone();
+  const response = entry.response?.clone();
+  const url = new URL(request.url);
+  const activity = entry.activity;
+  const object = await activity?.getObject();
+
+  const table = new Table({
+    chars: tableStyle,
+    style: { head: [], border: [] },
+  });
+
+  table.push(
+    { "Request #:": colors.bold(idx.toString()) },
+    {
+      "Activity type:": activity == null
+        ? colors.red("failed to parse")
+        : colors.green(
+          `${activity.constructor.name}(${object?.constructor.name})`,
+        ),
+    },
+    {
+      "HTTP request:": `${
+        request.method === "POST"
+          ? colors.green("POST")
+          : colors.red(request.method)
+      } ${url.pathname + url.search}`,
+    },
+    ...(response == null ? [] : [{
+      "HTTP response:": `${
+        response.ok
+          ? colors.green(response.status.toString())
+          : colors.red(response.status.toString())
+      } ${response.statusText}`,
+    }]),
+    { "Details": new URL(`/r/${idx}`, url).href },
+  );
+
+  console.log(table.toString());
+}
+
+function getHandle<T extends string>(
+  c: HonoContext<BlankEnv, T, BlankInput>,
+): string {
+  const url = new URL(c.req.url);
+  return `@i@${url.host}`;
+}
+
+const app = new Hono();
+
+app.get("/", (c) => c.redirect("/r"));
+
+app.get(
+  "/r",
+  (c) =>
+    c.html(
+      <ActivityListPage handle={getHandle(c)} entries={activities} />,
+    ),
+);
+
+app.get("/r/:idx{[0-9]+}", (c) => {
+  const idx = parseInt(c.req.param("idx"));
+  const tab = c.req.query("tab") ?? "request";
+  const activity = activities[idx];
+  if (activity == null) return c.notFound();
+  if (
+    tab !== "request" && tab !== "response" && tab !== "raw-activity" &&
+    tab !== "compact-activity" && tab !== "expanded-activity" && tab !== "logs"
+  ) {
+    return c.notFound();
+  }
+  return c.html(
+    <ActivityEntryPage
+      handle={getHandle(c)}
+      idx={idx}
+      entry={activity}
+      tabPage={tab}
+    />,
+  );
+});
+
+function createFetchHandler(
+  actorOptions: { actorName: string; actorSummary: string },
+): (request: Request) => Promise<Response> {
+  return async function fetch(request: Request): Promise<Response> {
+    const timestamp = Temporal.Now.instant();
+    const idx = activities.length;
+    const pathname = new URL(request.url).pathname;
+    if (pathname === "/r" || pathname.startsWith("/r/")) {
+      return app.fetch(request);
+    }
+    const inboxRequest = pathname === "/inbox" ||
+      pathname.startsWith("/i/inbox");
+    if (inboxRequest) {
+      recordingSink.startRecording();
+      // @ts-ignore: Work around `deno publish --dry-run` bug
+      activities.push({ timestamp, request: request.clone(), logs: [] });
+    }
+    const response = await federation.fetch(request, {
+      contextData: {
+        activityIndex: inboxRequest ? idx : -1,
+        actorName: actorOptions.actorName,
+        actorSummary: actorOptions.actorSummary,
+      },
+      onNotAcceptable: app.fetch.bind(app),
+      onNotFound: app.fetch.bind(app),
+      onUnauthorized: app.fetch.bind(app),
+    });
+    if (inboxRequest) {
+      recordingSink.stopRecording();
+      activities[idx].response = response.clone();
+      activities[idx].logs = recordingSink.getRecords();
+      await printActivityEntry(idx, activities[idx]);
+    }
+    return response;
+  };
+}

package/src/init/action/configs.ts

@@ -0,0 +1,88 @@
+import { join as joinPath } from "node:path";
+import biome from "../json/biome.json" with { type: "json" };
+import vscodeSettingsForDeno from "../json/vscode-settings-for-deno.json" with {
+  type: "json",
+};
+import vscodeSettings from "../json/vscode-settings.json" with {
+  type: "json",
+};
+import type { InitCommandData } from "../types.ts";
+
+/**
+ * Loads Deno configuration object with compiler options, unstable features, and tasks.
+ * Combines unstable features required by KV store and message queue with framework-specific options.
+ *
+ * @param param0 - Destructured initialization data containing KV, MQ, initializer, and directory
+ * @returns Configuration object with path and Deno-specific settings
+ */
+export const loadDenoConfig = (
+  { kv, mq, initializer, dir }: InitCommandData,
+) => ({
+  path: joinPath(dir, "deno.json"),
+  data: {
+    compilerOptions: initializer.compilerOptions,
+  },
+  unstable: [
+    "temporal",
+    ...kv.denoUnstable ?? [],
+    ...mq.denoUnstable ?? [],
+  ],
+  tasks: initializer.tasks,
+});
+
+/**
+ * Loads TypeScript configuration object for Node.js/Bun projects.
+ * Uses compiler options from the framework initializer.
+ *
+ * @param param0 - Destructured initialization data containing initializer and directory
+ * @returns Configuration object with path and TypeScript compiler options
+ */
+export const loadTsConfig = ({ initializer, dir }: InitCommandData) => ({
+  path: joinPath(dir, "tsconfig.json"),
+  data: {
+    compilerOptions: initializer.compilerOptions,
+  },
+});
+
+/**
+ * Loads package.json configuration object for Node.js/Bun projects.
+ * Sets up ES modules and includes framework-specific npm scripts.
+ *
+ * @param param0 - Destructured initialization data containing initializer and directory
+ * @returns Configuration object with path and package.json settings
+ */
+export const loadPackageJson = ({ initializer, dir }: InitCommandData) => ({
+  path: joinPath(dir, "package.json"),
+  data: {
+    type: "module",
+    scripts: initializer.tasks,
+  },
+});
+
+/**
+ * Configuration objects for various development tool setup files.
+ * Contains predefined configurations for code formatting, VS Code settings, and extensions
+ * based on the project type (Node.js/Bun or Deno).
+ */
+export const devToolConfigs = {
+  biome: {
+    path: joinPath("biome.json"),
+    data: biome,
+  },
+  vscExt: {
+    path: joinPath(".vscode", "extensions.json"),
+    data: { recommendations: ["biomejs.biome"] },
+  },
+  vscSet: {
+    path: joinPath(".vscode", "settings.json"),
+    data: vscodeSettings,
+  },
+  vscSetDeno: {
+    path: joinPath(".vscode", "settings.json"),
+    data: vscodeSettingsForDeno,
+  },
+  vscExtDeno: {
+    path: joinPath(".vscode", "extensions.json"),
+    data: { recommendations: ["denoland.vscode-deno"] },
+  },
+} as const;

package/src/init/action/deps.ts

@@ -0,0 +1,93 @@
+import { entries, map, pipe, toArray } from "@fxts/core";
+import { merge } from "../../utils.ts";
+import { PACKAGE_VERSION } from "../lib.ts";
+import type { InitCommandData, PackageManager } from "../types.ts";
+
+type Deps = Record<string, string>;
+
+/**
+ * Gathers all dependencies required for the project based on the initializer,
+ * key-value store, and message queue configurations.
+ *
+ * @param data - Web Framework initializer, key-value store and message queue descriptions
+ * @returns A record of dependencies with their versions
+ */
+export const getDependencies = (
+  { initializer, kv, mq }: InitCommandData,
+): Deps =>
+  pipe(
+    {
+      "@fedify/fedify": PACKAGE_VERSION,
+      "@logtape/logtape": "^1.1.0",
+    },
+    merge(initializer.dependencies),
+    merge(kv.dependencies),
+    merge(mq.dependencies),
+  );
+
+/** Gathers all devDependencies required for the project based on the initializer,
+ * key-value store, and message queue configurations, including Biome for linting/formatting.
+ *
+ * @param data - Web Framework initializer, key-value store and message queue descriptions
+ * @returns A record of devDependencies with their versions
+ */
+export const getDevDependencies = (
+  { initializer, kv, mq }: InitCommandData,
+): Deps =>
+  pipe(
+    {
+      "@biomejs/biome": "^2.2.4",
+    },
+    merge(initializer.devDependencies),
+    merge(kv.devDependencies),
+    merge(mq.devDependencies),
+  );
+
+/**
+ * Generates the command-line arguments needed to add dependencies or devDependencies
+ * using the specified package manager.
+ * If it is devDependencies, the '-D' flag is included.
+ *
+ * @param param0 - Object containing the package manager and a boolean indicating if dev dependencies are to be added
+ * @yields The command-line arguments as strings
+ */
+export function* getAddDepsArgs<
+  T extends { packageManager: PackageManager; dev?: boolean },
+>({ packageManager, dev = false }: T): Generator<string> {
+  yield packageManager;
+  yield "add";
+  if (dev) yield "-D";
+}
+
+/**
+ * Joins package names with their versions for installation commands.
+ * For Deno, it prefixes packages with 'jsr:' unless they already start with 'npm:'.
+ *
+ * @param data - Package manager and dependencies to be joined with versions
+ * @returns `${registry}:${package}@${version}`[] for deno or `${package}@${version}`[] for others
+ */
+export const joinDepsVer = <
+  T extends { packageManager: PackageManager; dependencies: Deps },
+>({ packageManager: pm, dependencies }: T): string[] =>
+  pipe(
+    dependencies,
+    entries,
+    map(([name, version]) =>
+      `${getPackageName(pm, name)}@${getPackageVersion(pm, version)}`
+    ),
+    toArray,
+  );
+
+const getPackageName = (pm: PackageManager, name: string) =>
+  pm !== "deno"
+    ? name
+    : name.startsWith("npm:")
+    ? name.substring(4)
+    : !name.startsWith("npm:")
+    ? `jsr:${name}`
+    : name;
+
+const getPackageVersion = (pm: PackageManager, version: string) =>
+  pm !== "deno" && version.includes("+")
+    ? version.substring(0, version.indexOf("+"))
+    : version;