@fedify/cli 1.8.12 → 2.0.0-dev.1761

package/dist/tunnel.js

@@ -0,0 +1,21 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { debugOption } from "./globals.js";
+import { argument, command, constant, integer, merge, message, object } from "@optique/core";
+
+//#region src/tunnel.ts
+const tunnelCommand = command("tunnel", merge(object({
+	command: constant("tunnel"),
+	port: argument(integer({
+		metavar: "PORT",
+		min: 0,
+		max: 65535
+	}))
+}), debugOption), { description: message`Expose a local HTTP server to the public internet using a secure tunnel.` });
+function runTunnel(command$1) {
+	console.debug(command$1);
+}
+
+//#endregion
+export { runTunnel, tunnelCommand };

package/dist/utils.js

@@ -0,0 +1,67 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { writeFile } from "node:fs/promises";
+import process from "node:process";
+import util from "node:util";
+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";
+
+//#region src/utils.ts
+const colorEnabled = process.stdout.isTTY && !("NO_COLOR" in process.env && process.env.NO_COLOR !== "");
+const colors = new Chalk(colorEnabled ? {} : { level: 0 });
+function formatObject(obj, colors$1, json) {
+	const enableColors = colors$1 ?? 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;
+}
+const isPromise = (a) => a instanceof Promise;
+function set(key, f) {
+	return (obj) => {
+		const result = f(obj);
+		if (isPromise(result)) return result.then((value) => ({
+			...obj,
+			[key]: value
+		}));
+		return {
+			...obj,
+			[key]: result
+		};
+	};
+}
+const merge = (source = {}) => (target = {}) => toMerged(target, source);
+const isNotFoundError = (e) => isObject(e) && "code" in e && e.code === "ENOENT";
+const runSubCommand = (command, options) => 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);
+	});
+});
+const getCwd = () => process.cwd();
+const replace = (pattern, replacement) => (text) => text.replace(pattern, replacement);
+const getOsType = () => process.platform;
+const formatJson = (obj) => JSON.stringify(obj, null, 2) + "\n";
+const notEmpty = (s) => s.length > 0;
+const exit = (code) => process.exit(code);
+
+//#endregion
+export { colorEnabled, colors, exit, formatJson, formatObject, getCwd, getOsType, isNotFoundError, merge, notEmpty, replace, runSubCommand, set };

package/dist/webfinger/action.js

@@ -0,0 +1,44 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { formatObject } from "../utils.js";
+import { NotFoundError, getErrorMessage } from "./error.js";
+import { convertUrlIfHandle } from "./lib.js";
+import { print } from "@optique/run";
+import ora from "ora";
+import { formatMessage, message } from "@optique/core/message";
+import { lookupWebFinger } from "@fedify/fedify/webfinger";
+
+//#region src/webfinger/action.ts
+async function runWebFinger({ command: _, resources,...options }) {
+	await Array.fromAsync(resources.map((resource) => ({
+		resource,
+		...options
+	})), spinnerWrapper(lookupSingleWebFinger));
+}
+async function lookupSingleWebFinger({ resource,...options }) {
+	const url = convertUrlIfHandle(resource);
+	const webFinger = await lookupWebFinger(url, options) ?? new NotFoundError(resource).throw();
+	return webFinger;
+}
+function spinnerWrapper(func) {
+	return async (...args) => {
+		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)));
+		}
+	};
+}
+
+//#endregion
+export { runWebFinger };

package/dist/webfinger/command.js

@@ -0,0 +1,20 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { debugOption } from "../globals.js";
+import { argument, command, constant, flag, integer, merge, message, multiple, object, option, optional, string, withDefault } from "@optique/core";
+
+//#region src/webfinger/command.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);
+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.` });
+
+//#endregion
+export { webFingerCommand };

package/dist/webfinger/error.js

@@ -0,0 +1,47 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { message } from "@optique/core";
+
+//#region src/webfinger/error.ts
+/**
+* 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.
+*/
+const getErrorMessage = (resource, error) => 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}
+*/
+var InvalidHandleError = class extends Error {
+	constructor(handle) {
+		super(`Invalid handle format: ${handle}`);
+		this.handle = handle;
+		this.name = "InvalidHandleError";
+	}
+	throw() {
+		throw this;
+	}
+};
+/**
+* Custom error class for not found resources.
+* @param {string} resource The resource that was not found.
+* @extends {Error}
+*/
+var NotFoundError = class extends Error {
+	constructor(resource) {
+		super(`Resource not found: ${resource}`);
+		this.resource = resource;
+		this.name = "NotFoundError";
+	}
+	throw() {
+		throw this;
+	}
+};
+
+//#endregion
+export { InvalidHandleError, NotFoundError, getErrorMessage };

package/dist/webfinger/lib.js

@@ -0,0 +1,45 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { InvalidHandleError } from "./error.js";
+import { toAcctUrl } from "@fedify/fedify";
+import { getLogger } from "@logtape/logtape";
+
+//#region src/webfinger/lib.ts
+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.
+*/
+function convertUrlIfHandle(handleOrUrl) {
+	try {
+		return new URL(handleOrUrl);
+	} catch {
+		return convertHandleToUrl(handleOrUrl);
+	}
+}
+/**
+* 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"
+* ```
+*/
+function convertHandleToUrl(handle) {
+	return toAcctUrl(handle) ?? new InvalidHandleError(handle).throw();
+}
+
+//#endregion
+export { convertUrlIfHandle };

package/dist/webfinger/mod.js

@@ -0,0 +1,5 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { runWebFinger } from "./action.js";
+import { webFingerCommand } from "./command.js";

package/package.json

@@ -1,28 +1,6 @@
 {
   "name": "@fedify/cli",
-  "version": "1.8.12",
-  "type": "module",
-  "files": [
-    "README.md",
-    "package.json",
-    "src/install.mjs",
-    "src/run.mjs"
-  ],
-  "bin": {
-    "fedify": "./src/run.mjs"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "os": [
-    "darwin",
-    "linux",
-    "win32"
-  ],
-  "cpu": [
-    "x64",
-    "arm64"
-  ],
+  "version": "2.0.0-dev.1761+9e73442d",
   "description": "CLI toolchain for Fedify and debugging ActivityPub",
   "keywords": [
     "fedify",
@@ -49,7 +27,69 @@
     "url": "git+https://github.com/fedify-dev/fedify.git",
     "directory": "packages/cli"
   },
+  "type": "module",
+  "engines": {
+    "node": ">=20.0.0",
+    "bun": ">=1.2.0",
+    "denp": ">=2.0.0"
+  },
+  "bin": {
+    "fedify": "./dist/mod.js"
+  },
+  "exports": "./dist/mod.js",
+  "imports": {
+    "#kv": {
+      "bun": "./dist/kv.bun.js",
+      "default": "./dist/kv.node.js"
+    }
+  },
+  "dependencies": {
+    "@fxts/core": "^1.15.0",
+    "@hongminhee/localtunnel": "^0.3.0",
+    "@inquirer/prompts": "^7.8.4",
+    "@jimp/core": "^1.6.0",
+    "@jimp/wasm-webp": "^1.6.0",
+    "@js-temporal/polyfill": "^0.5.1",
+    "@logtape/file": "^1.1.1",
+    "@logtape/logtape": "^1.1.1",
+    "@optique/core": "^0.6.1",
+    "@optique/run": "^0.6.1",
+    "@poppanator/http-constants": "^1.1.1",
+    "byte-encodings": "^1.0.11",
+    "chalk": "^5.6.2",
+    "cli-highlight": "^2.1.11",
+    "cli-table3": "^0.6.5",
+    "enquirer": "^2.4.1",
+    "env-paths": "^3.0.0",
+    "es-toolkit": "1.39.5",
+    "fetch-mock": "^12.5.4",
+    "hono": "^4.8.3",
+    "icojs": "^0.19.5",
+    "inquirer": "^12.9.4",
+    "inquirer-toggle": "^1.0.1",
+    "jimp": "^1.6.0",
+    "ora": "^8.2.0",
+    "shiki": "^1.6.4",
+    "srvx": "^0.8.7",
+    "@fedify/fedify": "2.0.0-dev.1761+9e73442d",
+    "@fedify/sqlite": "2.0.0-dev.1761+9e73442d",
+    "@fedify/vocab-runtime": "2.0.0-dev.1761+9e73442d"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.2.23",
+    "@types/node": "^22.16.0",
+    "tsdown": "^0.12.9",
+    "typescript": "^5.9.2"
+  },
   "scripts": {
-    "postinstall": "node src/install.mjs"
+    "codegen": "deno task -f @fedify/fedify codegen",
+    "build": "pnpm run codegen && pnpm run --filter fedify build && pnpm run --filter sqlite build && tsdown",
+    "prepublish": "pnpm run build",
+    "test": "pnpm build && node --test --experimental-transform-types",
+    "test:bun": "pnpm build && bun test",
+    "run": "pnpm build && node dist/mod.js",
+    "runi": "tsdown && node dist/mod.js",
+    "run:bun": "pnpm build && bun dist/mod.js",
+    "runi:bun": "tsdown && bun dist/mod.js"
   }
 }

package/scripts/pack.ts

@@ -0,0 +1,64 @@
+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 --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 promises: Promise<void>[] = [];
+for (const osKey in triplets) {
+  const os = osKey as OS;
+  for (const arch in triplets[os]) {
+    const promise = pack(os, arch as Arch);
+    promises.push(promise);
+  }
+}
+await Promise.all(promises);
+
+// cSpell: ignore cfvz

package/src/cache.ts

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

@@ -0,0 +1,67 @@
+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/globals.ts

@@ -0,0 +1,43 @@
+import { message, object, option } from "@optique/core";
+import { configure, getConsoleSink } from "@logtape/logtape";
+import { getFileSink } from "@logtape/file";
+import { recordingSink } from "./log.ts";
+import { AsyncLocalStorage } from "node:async_hooks";
+import process from "node:process";
+
+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(),
+  });
+}