@fedify/cli 2.0.0-pr.479.1922 → 2.0.0

package/dist/init/test/run.js

@@ -1,25 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-    
-import { printMessage } from "../../utils.js";
-import create_default, { filterOptions, generateTestCases } from "./create.js";
-import { runServerAndLookupUser } from "./lookup.js";
-import { join } from "node:path";
-import { optionNames } from "@optique/core";
-import { always, filter, map as map$1, pipe, tap, unless } from "@fxts/core";
-
-//#region src/init/test/run.ts
-const runTests = (dry) => ({ testDirPrefix, dryRun, hydRun,...options }) => pipe(options, printStartMessage(dry), generateTestCases, filter(filterOptions), map$1(create_default(join(testDirPrefix, getMid(dryRun, hydRun, dry)), dry)), Array.fromAsync, unless(always(dry), runServerAndLookupUser));
-var run_default = runTests;
-const printStartMessage = (dry) => tap(() => printMessage`\n
-Init ${dry ? "Dry" : "Hyd"} Test start!
-Options: ${optionNames([
-	"Web Framework",
-	"Package Manager",
-	"KV Store",
-	"Message Queue"
-])}`);
-const getMid = (dryRun, hydRun, dry) => dryRun === hydRun ? dry ? "dry" : "hyd" : "";
-
-//#endregion
-export { run_default as default };

package/dist/init/test/utils.js

@@ -1,17 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-    
-import { printMessage } from "../../utils.js";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-//#region src/init/test/utils.ts
-const genRunId = () => `${Date.now()}-${Math.random().toString(36).slice(2)}`;
-const genTestDirPrefix = ({ runId }) => join(tmpdir(), "fedify-init", runId);
-const emptyTestDir = ({ testDirPrefix }) => Deno.remove(testDirPrefix, { recursive: true }).catch(() => {});
-const logTestDir = ({ runId, testDirPrefix }) => printMessage`Test run completed.
-Run ID: ${runId}
-Path: ${testDirPrefix}`;
-
-//#endregion
-export { emptyTestDir, genRunId, genTestDirPrefix, logTestDir };

package/dist/init/webframeworks.js

@@ -1,136 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-    
-import { replace } from "../utils.js";
-import { PACKAGE_MANAGER } from "./const.js";
-import { PACKAGE_VERSION, getInstruction, getNextInitCommand, getNitroInitCommand, packageManagerToRuntime, readTemplate } from "./lib.js";
-import { pipe } from "@fxts/core";
-
-//#region src/init/webframeworks.ts
-const webFrameworks = {
-	hono: {
-		label: "Hono",
-		packageManagers: PACKAGE_MANAGER,
-		init: ({ projectName, packageManager: pm }) => ({
-			dependencies: pm === "deno" ? {
-				"@std/dotenv": "^0.225.2",
-				"@hono/hono": "^4.5.0",
-				"@hongminhee/x-forwarded-fetch": "^0.2.0",
-				"@fedify/hono": PACKAGE_VERSION
-			} : pm === "bun" ? {
-				hono: "^4.5.0",
-				"x-forwarded-fetch": "^0.2.0",
-				"@fedify/hono": PACKAGE_VERSION
-			} : {
-				"@dotenvx/dotenvx": "^1.14.1",
-				hono: "^4.5.0",
-				"@hono/node-server": "^1.12.0",
-				tsx: "^4.17.0",
-				"x-forwarded-fetch": "^0.2.0",
-				"@fedify/hono": PACKAGE_VERSION
-			},
-			devDependencies: pm === "bun" ? { "@types/bun": "^1.1.6" } : {},
-			federationFile: "src/federation.ts",
-			loggingFile: "src/logging.ts",
-			files: {
-				"src/app.tsx": pipe("hono/app.tsx", readTemplate, replace(/\/\* hono \*\//, pm === "deno" ? "@hono/hono" : "hono"), replace(/\/\* logger \*\//, projectName)),
-				"src/index.ts": readTemplate(`hono/index/${packageManagerToRuntime(pm)}.ts`)
-			},
-			compilerOptions: pm === "deno" ? void 0 : {
-				"lib": ["ESNext", "DOM"],
-				"target": "ESNext",
-				"module": "NodeNext",
-				"moduleResolution": "NodeNext",
-				"allowImportingTsExtensions": true,
-				"verbatimModuleSyntax": true,
-				"noEmit": true,
-				"strict": true,
-				"jsx": "react-jsx",
-				"jsxImportSource": "hono/jsx"
-			},
-			tasks: {
-				"dev": pm === "deno" ? "deno run -A --watch ./src/index.ts" : pm === "bun" ? "bun run --hot ./src/index.ts" : "dotenvx run -- tsx watch ./src/index.ts",
-				"prod": pm === "deno" ? "deno run -A ./src/index.ts" : pm === "bun" ? "bun run ./src/index.ts" : "dotenvx run -- node --import tsx ./src/index.ts"
-			},
-			instruction: getInstruction(pm, 8e3)
-		}),
-		defaultPort: 8e3
-	},
-	express: {
-		label: "Express",
-		packageManagers: PACKAGE_MANAGER,
-		init: ({ projectName, packageManager: pm }) => ({
-			dependencies: {
-				"npm:express": "^4.19.2",
-				"@fedify/express": PACKAGE_VERSION,
-				...pm !== "deno" && pm !== "bun" ? {
-					"@dotenvx/dotenvx": "^1.14.1",
-					tsx: "^4.17.0"
-				} : {}
-			},
-			devDependencies: {
-				"@types/express": "^4.17.21",
-				...pm === "bun" ? { "@types/bun": "^1.1.6" } : {}
-			},
-			federationFile: "src/federation.ts",
-			loggingFile: "src/logging.ts",
-			files: {
-				"src/app.ts": readTemplate("express/app.ts").replace(/\/\* logger \*\//, projectName),
-				"src/index.ts": readTemplate("express/index.ts")
-			},
-			compilerOptions: pm === "deno" ? void 0 : {
-				"lib": ["ESNext", "DOM"],
-				"target": "ESNext",
-				"module": "NodeNext",
-				"moduleResolution": "NodeNext",
-				"allowImportingTsExtensions": true,
-				"verbatimModuleSyntax": true,
-				"noEmit": true,
-				"strict": true
-			},
-			tasks: {
-				"dev": pm === "bun" ? "bun run --hot ./src/index.ts" : pm === "deno" ? "deno run --allow-net --allow-env --allow-sys --watch ./src/index.ts" : "dotenvx run -- tsx watch ./src/index.ts",
-				"prod": pm === "bun" ? "bun run ./src/index.ts" : pm === "deno" ? "deno run --allow-net --allow-env --allow-sys ./src/index.ts" : "dotenvx run -- node --import tsx ./src/index.ts"
-			},
-			instruction: getInstruction(pm, 8e3)
-		}),
-		defaultPort: 8e3
-	},
-	nitro: {
-		label: "Nitro",
-		packageManagers: PACKAGE_MANAGER,
-		init: ({ packageManager: pm, testMode }) => ({
-			command: getNitroInitCommand(pm),
-			dependencies: { "@fedify/h3": PACKAGE_VERSION },
-			federationFile: "server/federation.ts",
-			loggingFile: "server/logging.ts",
-			files: {
-				"server/middleware/federation.ts": readTemplate("nitro/server/middleware/federation.ts"),
-				"server/error.ts": readTemplate("nitro/server/error.ts"),
-				"nitro.config.ts": readTemplate("nitro/nitro.config.ts"),
-				...testMode ? { ".env": readTemplate("nitro/.env.test") } : {}
-			},
-			instruction: getInstruction(pm, 3e3)
-		}),
-		defaultPort: 3e3
-	},
-	next: {
-		label: "Next.js",
-		packageManagers: PACKAGE_MANAGER,
-		init: ({ packageManager: pm }) => ({
-			label: "Next.js",
-			command: getNextInitCommand(pm),
-			dependencies: { "@fedify/next": PACKAGE_VERSION },
-			devDependencies: { "@types/node": "^20.11.2" },
-			federationFile: "federation/index.ts",
-			loggingFile: "logging.ts",
-			files: { "middleware.ts": readTemplate("next/middleware.ts") },
-			instruction: getInstruction(pm, 3e3)
-		}),
-		defaultPort: 3e3
-	}
-};
-var webframeworks_default = webFrameworks;
-
-//#endregion
-export { webframeworks_default as default };

package/scripts/pack.ts

@@ -1,71 +0,0 @@
-import $ from "@david/dax";
-import { dirname, join } from "@std/path";
-import metadata from "../deno.json" with { type: "json" };
-
-type OS = "linux" | "macos" | "windows";
-type Arch = "x86_64" | "aarch64";
-
-const triplets: Record<OS, Partial<Record<Arch, string>>> = {
-  linux: {
-    x86_64: "x86_64-unknown-linux-gnu",
-    aarch64: "aarch64-unknown-linux-gnu",
-  },
-  macos: {
-    x86_64: "x86_64-apple-darwin",
-    aarch64: "aarch64-apple-darwin",
-  },
-  windows: {
-    x86_64: "x86_64-pc-windows-msvc",
-  },
-};
-
-async function compile(os: OS, arch: Arch, into: string): Promise<void> {
-  const target = triplets[os][arch];
-  if (!target) {
-    throw new Error(`Unsupported os/arch: ${os}/${arch}`);
-  }
-  await $`deno compile --allow-all --include=${
-    join("src", "init", "templates")
-  } --target=${target} --output=${into} ${
-    join(dirname(import.meta.dirname!), "src", "mod.ts")
-  }`;
-}
-
-async function pack(os: OS, arch: Arch): Promise<void> {
-  const dir = await Deno.makeTempDir();
-  await compile(os, arch, join(dir, "fedify"));
-  await Deno.copyFile(
-    join(dirname(import.meta.dirname!), "README.md"),
-    join(dir, "README.md"),
-  );
-  await Deno.copyFile(
-    join(dirname(dirname(dirname(import.meta.dirname!))), "LICENSE"),
-    join(dir, "LICENSE"),
-  );
-  if (os === "windows") {
-    const zipName = `fedify-cli-${metadata.version}-${os}-${arch}.zip`;
-    await $`7z a ${zipName} fedify.exe README.md LICENSE`.cwd(dir);
-    await Deno.copyFile(join(dir, zipName), zipName);
-  } else {
-    const tarName = `fedify-cli-${metadata.version}-${os}-${arch}.tar.xz`;
-    await $`tar cfvJ ${tarName} fedify README.md LICENSE`.cwd(dir);
-    await Deno.copyFile(join(dir, tarName), tarName);
-  }
-}
-
-const osFilter = Deno.env.get("OS")?.toLowerCase();
-const archFilter = Deno.env.get("ARCH")?.toLowerCase();
-
-const promises: Promise<void>[] = [];
-for (const osKey in triplets) {
-  const os = osKey as OS;
-  if (osFilter != null && osFilter !== os) continue;
-  for (const arch in triplets[os]) {
-    if (archFilter != null && archFilter !== arch) continue;
-    const promise = pack(os, arch as Arch);
-    promises.push(promise);
-  }
-}
-await Promise.all(promises);
-
-// cSpell: ignore cfvz

package/src/cache.ts

@@ -1,17 +0,0 @@
-import envPaths from "env-paths";
-import { mkdir } from "node:fs/promises";
-
-const paths = envPaths("fedify", { suffix: "" });
-export const DEFAULT_CACHE_DIR = paths.cache;
-
-let currentCacheDir: string = DEFAULT_CACHE_DIR;
-
-export async function getCacheDir(): Promise<string> {
-  await mkdir(currentCacheDir, { recursive: true });
-  return currentCacheDir;
-}
-
-export function setCacheDir(dir: string): Promise<void> {
-  currentCacheDir = dir;
-  return Promise.resolve();
-}

package/src/docloader.ts

@@ -1,67 +0,0 @@
-import { kvCache } from "@fedify/fedify";
-import {
-  type DocumentLoader,
-  getDocumentLoader as getDefaultDocumentLoader,
-} from "@fedify/vocab-runtime";
-import { getKvStore } from "#kv";
-
-const documentLoaders: Record<string, DocumentLoader> = {};
-
-export interface DocumentLoaderOptions {
-  userAgent?: string;
-}
-
-export async function getDocumentLoader(
-  { userAgent }: DocumentLoaderOptions = {},
-): Promise<DocumentLoader> {
-  if (documentLoaders[userAgent ?? ""]) return documentLoaders[userAgent ?? ""];
-  const kv = await getKvStore();
-  return documentLoaders[userAgent ?? ""] = kvCache({
-    kv,
-    rules: [
-      [
-        new URLPattern({
-          protocol: "http{s}?",
-          hostname: "localhost",
-          port: "*",
-          pathname: "/*",
-          search: "*",
-          hash: "*",
-        }),
-        { seconds: 0 },
-      ],
-      [
-        new URLPattern({
-          protocol: "http{s}?",
-          hostname: "127.0.0.1",
-          port: "*",
-          pathname: "/*",
-          search: "*",
-          hash: "*",
-        }),
-        { seconds: 0 },
-      ],
-      [
-        new URLPattern({
-          protocol: "http{s}?",
-          hostname: "\\[\\:\\:1\\]",
-          port: "*",
-          pathname: "/*",
-          search: "*",
-          hash: "*",
-        }),
-        { seconds: 0 },
-      ],
-    ],
-    loader: getDefaultDocumentLoader({
-      allowPrivateAddress: true,
-      userAgent,
-    }),
-  });
-}
-
-export function getContextLoader(
-  options: DocumentLoaderOptions = {},
-): Promise<DocumentLoader> {
-  return getDocumentLoader(options);
-}

package/src/generate-vocab/action.ts

@@ -1,17 +0,0 @@
-import { generateVocab } from "@fedify/vocab-tools";
-import { message } from "@optique/core/message";
-import { printError } from "@optique/run";
-import { stat } from "node:fs/promises";
-import process from "node:process";
-import type { GenerateVocabCommand } from "./command.ts";
-
-export default async function runGenerateVocab(
-  { schemaDir, generatedPath }: GenerateVocabCommand,
-) {
-  if (!(await stat(schemaDir)).isDirectory()) {
-    printError(message`${schemaDir} is not a directory.`);
-    process.exit(1);
-  }
-
-  await generateVocab(schemaDir, generatedPath);
-}

package/src/generate-vocab/command.ts

@@ -1,44 +0,0 @@
-import {
-  argument,
-  command,
-  constant,
-  type InferValue,
-  message,
-  object,
-  option,
-  withDefault,
-} from "@optique/core";
-import { path } from "@optique/run";
-
-const schemaDir = withDefault(
-  option(
-    "-i",
-    "--input",
-    path({ metavar: "DIR", type: "directory", mustExist: true }),
-    { description: message`Directory containing schema files.` },
-  ),
-  ".",
-);
-const generatedPath = argument(
-  path({ metavar: "PATH", type: "file", allowCreate: true }),
-  {
-    description:
-      message`Path to output the generated vocabulary classes.  Should end with ${".ts"} suffix.`,
-  },
-);
-
-const generateVocabCommand = command(
-  "generate-vocab",
-  object("Generation options", {
-    command: constant("generate-vocab"),
-    schemaDir,
-    generatedPath,
-  }),
-  {
-    description: message`Generate vocabulary classes from schema files.`,
-  },
-);
-
-export default generateVocabCommand;
-
-export type GenerateVocabCommand = InferValue<typeof generateVocabCommand>;

package/src/generate-vocab/mod.ts

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

package/src/globals.ts

@@ -1,43 +0,0 @@
-import { getFileSink } from "@logtape/file";
-import { configure, getConsoleSink } from "@logtape/logtape";
-import { message, object, option } from "@optique/core";
-import { AsyncLocalStorage } from "node:async_hooks";
-import process from "node:process";
-import { recordingSink } from "./log.ts";
-
-export const debugOption = object("Global options", {
-  debug: option("-d", "--debug", {
-    description: message`Enable debug mode.`,
-  }),
-});
-
-export async function configureLogging() {
-  const logFile = process.env["FEDIFY_LOG_FILE"];
-  await configure({
-    sinks: {
-      console: getConsoleSink(),
-      recording: recordingSink,
-      file: logFile == null ? () => undefined : getFileSink(logFile),
-    },
-    filters: {},
-    loggers: [
-      {
-        category: "fedify",
-        lowestLevel: "debug",
-        sinks: ["console", "recording", "file"],
-      },
-      {
-        category: "localtunnel",
-        lowestLevel: "debug",
-        sinks: ["console", "file"],
-      },
-      {
-        category: ["logtape", "meta"],
-        lowestLevel: "warning",
-        sinks: ["console", "file"],
-      },
-    ],
-    reset: true,
-    contextLocalStorage: new AsyncLocalStorage(),
-  });
-}

package/src/imagerenderer.ts

@@ -1,149 +0,0 @@
-import { encodeBase64 } from "byte-encodings/base64";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import process from "node:process";
-import { Jimp } from "./nodeinfo.ts";
-
-export type TerminalType = "kitty" | "iterm2" | "none";
-
-const KITTY_IDENTIFIERS: string[] = [
-  "kitty",
-  "wezterm",
-  "konsole",
-  "warp",
-  "wayst",
-  "st",
-  "ghostty",
-];
-
-type KittyCommand = Record<string, string | number>;
-
-export function detectTerminalCapabilities(): TerminalType {
-  const termProgram = (process.env.TERM_PROGRAM || "").toLowerCase();
-
-  if (KITTY_IDENTIFIERS.includes(termProgram)) return "kitty";
-
-  if (termProgram === "iterm.app") return "iterm2";
-
-  return "none";
-}
-
-function serializeGrCommand(
-  cmd: KittyCommand,
-  payload?: string,
-): Uint8Array {
-  const cmdString = Object.entries(cmd)
-    .map(([k, v]) => `${k}=${v}`)
-    .join(",");
-
-  const encoder = new TextEncoder();
-  const parts: Uint8Array[] = [];
-
-  parts.push(encoder.encode("\x1b_G"));
-  parts.push(encoder.encode(cmdString));
-
-  if (payload) {
-    parts.push(encoder.encode(";"));
-    parts.push(encoder.encode(payload));
-  }
-
-  parts.push(encoder.encode("\x1b\\"));
-
-  const totalLength = parts.reduce((sum, part) => sum + part.length, 0);
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-
-  for (const part of parts) {
-    result.set(part, offset);
-    offset += part.length;
-  }
-
-  return result;
-}
-
-export async function renderImageKitty(
-  imagePath: string,
-  cmd: KittyCommand,
-): Promise<void> {
-  const imageData = await fs.readFile(imagePath);
-  const base64Data = encodeBase64(imageData);
-  let remaining = base64Data;
-  let isFirst = true;
-
-  while (remaining.length > 0) {
-    const chunk = remaining.slice(0, 4096);
-    remaining = remaining.slice(4096);
-
-    const chunkCmd = {
-      ...(isFirst ? cmd : {}),
-      m: remaining.length > 0 ? 1 : 0,
-    };
-
-    const command = serializeGrCommand(chunkCmd, chunk);
-
-    process.stderr.write(command);
-
-    isFirst = false;
-  }
-}
-
-export async function renderImageITerm2(
-  imagePath: string,
-): Promise<void> {
-  const imageData = await fs.readFile(imagePath);
-  const base64Data = encodeBase64(imageData);
-
-  const encoder = new TextEncoder();
-  const command = encoder.encode(
-    `\x1b]1337;File=inline=1preserveAspectRatio=1:${base64Data}\x07\n`,
-  );
-  process.stderr.write(command);
-}
-
-export async function downloadImage(url: string): Promise<string | null> {
-  try {
-    const response = await fetch(url);
-    const imageData = new Uint8Array(await response.arrayBuffer());
-    const extension = new URL(url).pathname.split(".").pop() || "jpg";
-    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "fedify"));
-    const tempPath = path.join(tempDir, `image.${extension}`);
-
-    await fs.writeFile(tempPath, imageData);
-
-    return tempPath;
-  } catch (_error) {
-    return null;
-  }
-}
-
-export async function renderImages(
-  imageUrls: URL[],
-): Promise<void> {
-  const graphicsProtocol = detectTerminalCapabilities();
-  for (const url of imageUrls) {
-    const tempPath = await downloadImage(url.href);
-    if (!tempPath) continue;
-
-    const convertedImagePath: `${string}.png` = `${tempPath}.converted.png`;
-    const image = await Jimp.read(tempPath);
-    await image.write(convertedImagePath);
-    await fs.rm(tempPath);
-
-    console.error(); // clear the line before rendering image
-
-    if (graphicsProtocol === "kitty") {
-      await renderImageKitty(convertedImagePath, {
-        a: "T",
-        f: 100, // specify the image format is png
-      });
-    } else if (graphicsProtocol === "iterm2") {
-      await renderImageITerm2(convertedImagePath);
-    } else {
-      continue;
-    }
-    console.error(); // clear the line after rendering image
-  }
-}
-
-// cSpell: ignore ghostty iterm konsole magick wezterm wayst

package/src/inbox/entry.ts

@@ -1,10 +0,0 @@
-import type { Activity } from "@fedify/fedify";
-import type { LogRecord } from "@logtape/logtape";
-
-export interface ActivityEntry {
-  timestamp: Temporal.Instant;
-  request: Request;
-  response?: Response;
-  activity?: Activity;
-  logs: LogRecord[];
-}

package/src/inbox/rendercode.ts

@@ -1,68 +0,0 @@
-import type { Activity } from "@fedify/fedify";
-import { getStatusText } from "@poppanator/http-constants";
-import { getContextLoader } from "../docloader.ts";
-
-export async function renderRequest(request: Request): Promise<string> {
-  // @ts-ignore: Work around `deno publish --dry-run` bug
-  request = request.clone();
-  const url = new URL(request.url);
-  let code = `${request.method} ${url.pathname + url.search}\n`;
-  for (const [key, value] of request.headers.entries()) {
-    code += `${capitalize(key)}: ${value}\n`;
-  }
-  let body: string;
-  try {
-    body = await request.text();
-  } catch (_) {
-    body = "[Failed to decode body; it may be binary.]";
-  }
-  code += `\n${body}`;
-  return code;
-}
-
-export async function renderResponse(response: Response): Promise<string> {
-  response = response.clone();
-  let code = `${response.status} ${
-    response.statusText === ""
-      ? getStatusText(response.status)
-      : response.statusText
-  }\n`;
-  for (const [key, value] of response.headers.entries()) {
-    code += `${capitalize(key)}: ${value}\n`;
-  }
-  let body: string;
-  try {
-    body = await response.text();
-  } catch (_) {
-    body = "[Failed to decode body; it may be binary.]";
-  }
-  code += `\n${body}`;
-  return code;
-}
-
-export async function renderRawActivity(request: Request): Promise<string> {
-  // @ts-ignore: Work around `deno publish --dry-run` bug
-  request = request.clone();
-  try {
-    const activity = await request.json();
-    return JSON.stringify(activity, null, 2);
-  } catch {
-    return "[Failed to decode body; it may not be JSON.]";
-  }
-}
-
-export async function renderActivity(
-  activity: Activity,
-  expand: boolean = false,
-): Promise<string> {
-  const contextLoader = await getContextLoader();
-  const jsonLd = await activity.toJsonLd({
-    contextLoader,
-    format: expand ? "expand" : "compact",
-  });
-  return JSON.stringify(jsonLd, null, 2);
-}
-
-function capitalize(name: string): string {
-  return name.replace(/(^|-)./g, (match) => match.toUpperCase());
-}