@fedify/cli 1.8.11 → 2.0.0-dev.1757

package/deno.json

@@ -0,0 +1,72 @@
+{
+  "name": "@fedify/cli",
+  "version": "2.0.0-dev.1757+5037a70f",
+  "license": "MIT",
+  "exports": "./src/mod.ts",
+  "imports": {
+    "@david/dax": "jsr:@david/dax@^0.43.2",
+    "@fxts/core": "npm:@fxts/core@^1.15.0",
+    "@hongminhee/localtunnel": "jsr:@hongminhee/localtunnel@^0.3.0",
+    "@inquirer/prompts": "npm:@inquirer/prompts@^7.8.4",
+    "@jimp/core": "npm:@jimp/core@^1.6.0",
+    "@jimp/wasm-webp": "npm:@jimp/wasm-webp@^1.6.0",
+    "@optique/core": "jsr:@optique/core@^0.6.1",
+    "@optique/run": "jsr:@optique/run@^0.6.1",
+    "@poppanator/http-constants": "npm:@poppanator/http-constants@^1.1.1",
+    "chalk": "npm:chalk@^5.6.2",
+    "cli-table3": "npm:cli-table3@^0.6.5",
+    "env-paths": "npm:env-paths@^3.0.0",
+    "fetch-mock": "npm:fetch-mock@^12.5.4",
+    "hono": "jsr:@hono/hono@^4.8.3",
+    "icojs": "npm:icojs@^0.19.5",
+    "inquirer-toggle": "npm:inquirer-toggle@^1.0.1",
+    "ora": "npm:ora@^8.2.0",
+    "shiki": "npm:shiki@^1.6.4",
+    "srvx": "npm:srvx@^0.8.7",
+    "#kv": "./src/kv.node.ts"
+  },
+  "exclude": [
+    "dist/",
+    "fedify-cli-*.tar.xz",
+    "fedify-cli-*.tgz",
+    "fedify-cli-*.zip"
+  ],
+  "tasks": {
+    "codegen": "deno task -f @fedify/fedify codegen",
+    "check": {
+      "command": "deno task codegen && deno fmt --check && deno lint && deno check src/**/*.ts",
+      "dependencies": [
+        "codegen"
+      ]
+    },
+    "run": {
+      "command": "deno run --allow-all src/mod.ts",
+      "dependencies": [
+        "codegen"
+      ]
+    },
+    "runi": "deno run --allow-all src/mod.ts",
+    "pack": {
+      "command": "deno run -A scripts/pack.ts",
+      "dependencies": [
+        "codegen"
+      ]
+    },
+    "test": {
+      "command": "deno test --allow-all",
+      "dependencies": [
+        "codegen"
+      ]
+    }
+  },
+  "fmt": {
+    "exclude": [
+      "src/init/templates/**"
+    ]
+  },
+  "lint": {
+    "exclude": [
+      "src/init/templates/**"
+    ]
+  }
+}

package/dist/cache.js

@@ -0,0 +1,17 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import envPaths from "env-paths";
+import { mkdir } from "node:fs/promises";
+
+//#region src/cache.ts
+const paths = envPaths("fedify", { suffix: "" });
+const DEFAULT_CACHE_DIR = paths.cache;
+let currentCacheDir = DEFAULT_CACHE_DIR;
+async function getCacheDir() {
+	await mkdir(currentCacheDir, { recursive: true });
+	return currentCacheDir;
+}
+
+//#endregion
+export { getCacheDir };

package/dist/deno.js

@@ -0,0 +1,72 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+//#region deno.json
+var name = "@fedify/cli";
+var version = "2.0.0-dev.1757+5037a70f";
+var license = "MIT";
+var exports = "./src/mod.ts";
+var imports = {
+	"@david/dax": "jsr:@david/dax@^0.43.2",
+	"@fxts/core": "npm:@fxts/core@^1.15.0",
+	"@hongminhee/localtunnel": "jsr:@hongminhee/localtunnel@^0.3.0",
+	"@inquirer/prompts": "npm:@inquirer/prompts@^7.8.4",
+	"@jimp/core": "npm:@jimp/core@^1.6.0",
+	"@jimp/wasm-webp": "npm:@jimp/wasm-webp@^1.6.0",
+	"@optique/core": "jsr:@optique/core@^0.6.1",
+	"@optique/run": "jsr:@optique/run@^0.6.1",
+	"@poppanator/http-constants": "npm:@poppanator/http-constants@^1.1.1",
+	"chalk": "npm:chalk@^5.6.2",
+	"cli-table3": "npm:cli-table3@^0.6.5",
+	"env-paths": "npm:env-paths@^3.0.0",
+	"fetch-mock": "npm:fetch-mock@^12.5.4",
+	"hono": "jsr:@hono/hono@^4.8.3",
+	"icojs": "npm:icojs@^0.19.5",
+	"inquirer-toggle": "npm:inquirer-toggle@^1.0.1",
+	"ora": "npm:ora@^8.2.0",
+	"shiki": "npm:shiki@^1.6.4",
+	"srvx": "npm:srvx@^0.8.7",
+	"#kv": "./src/kv.node.ts"
+};
+var exclude = [
+	"dist/",
+	"fedify-cli-*.tar.xz",
+	"fedify-cli-*.tgz",
+	"fedify-cli-*.zip"
+];
+var tasks = {
+	"codegen": "deno task -f @fedify/fedify codegen",
+	"check": {
+		"command": "deno task codegen && deno fmt --check && deno lint && deno check src/**/*.ts",
+		"dependencies": ["codegen"]
+	},
+	"run": {
+		"command": "deno run --allow-all src/mod.ts",
+		"dependencies": ["codegen"]
+	},
+	"runi": "deno run --allow-all src/mod.ts",
+	"pack": {
+		"command": "deno run -A scripts/pack.ts",
+		"dependencies": ["codegen"]
+	},
+	"test": {
+		"command": "deno test --allow-all",
+		"dependencies": ["codegen"]
+	}
+};
+var fmt = { "exclude": ["src/init/templates/**"] };
+var lint = { "exclude": ["src/init/templates/**"] };
+var deno_default = {
+	name,
+	version,
+	license,
+	exports,
+	imports,
+	exclude,
+	tasks,
+	fmt,
+	lint
+};
+
+//#endregion
+export { deno_default as default };

package/dist/docloader.js

@@ -0,0 +1,52 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { kvCache } from "@fedify/fedify";
+import { getDocumentLoader } from "@fedify/vocab-runtime";
+import { getKvStore } from "#kv";
+
+//#region src/docloader.ts
+const documentLoaders = {};
+async function getDocumentLoader$1({ userAgent } = {}) {
+	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: getDocumentLoader({
+			allowPrivateAddress: true,
+			userAgent
+		})
+	});
+}
+function getContextLoader(options = {}) {
+	return getDocumentLoader$1(options);
+}
+
+//#endregion
+export { getContextLoader, getDocumentLoader$1 as getDocumentLoader };

package/dist/globals.js

@@ -0,0 +1,49 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { recordingSink } from "./log.js";
+import { message, object, option } from "@optique/core";
+import { configure, getConsoleSink } from "@logtape/logtape";
+import process from "node:process";
+import { getFileSink } from "@logtape/file";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/globals.ts
+const debugOption = object("Global options", { debug: option("-d", "--debug", { description: message`Enable debug mode.` }) });
+async function configureLogging() {
+	const logFile = process.env["FEDIFY_LOG_FILE"];
+	await configure({
+		sinks: {
+			console: getConsoleSink(),
+			recording: recordingSink,
+			file: logFile == null ? () => void 0 : 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()
+	});
+}
+
+//#endregion
+export { configureLogging, debugOption };

package/dist/imagerenderer.js

@@ -0,0 +1,105 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { Jimp } from "./nodeinfo.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+import process from "node:process";
+import { encodeBase64 } from "byte-encodings/base64";
+import os from "node:os";
+
+//#region src/imagerenderer.ts
+const KITTY_IDENTIFIERS = [
+	"kitty",
+	"wezterm",
+	"konsole",
+	"warp",
+	"wayst",
+	"st",
+	"ghostty"
+];
+function detectTerminalCapabilities() {
+	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, payload) {
+	const cmdString = Object.entries(cmd).map(([k, v]) => `${k}=${v}`).join(",");
+	const encoder = new TextEncoder();
+	const parts = [];
+	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;
+}
+async function renderImageKitty(imagePath, cmd) {
+	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;
+	}
+}
+async function renderImageITerm2(imagePath) {
+	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);
+}
+async function downloadImage(url) {
+	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;
+	}
+}
+async function renderImages(imageUrls) {
+	const graphicsProtocol = detectTerminalCapabilities();
+	for (const url of imageUrls) {
+		const tempPath = await downloadImage(url.href);
+		if (!tempPath) continue;
+		const convertedImagePath = `${tempPath}.converted.png`;
+		const image = await Jimp.read(tempPath);
+		await image.write(convertedImagePath);
+		await fs.rm(tempPath);
+		console.error();
+		if (graphicsProtocol === "kitty") await renderImageKitty(convertedImagePath, {
+			a: "T",
+			f: 100
+		});
+		else if (graphicsProtocol === "iterm2") await renderImageITerm2(convertedImagePath);
+		else continue;
+		console.error();
+	}
+}
+
+//#endregion
+export { renderImages };

package/dist/inbox/rendercode.js

@@ -0,0 +1,57 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+    
+import { getContextLoader } from "../docloader.js";
+import { getStatusText } from "@poppanator/http-constants";
+
+//#region src/inbox/rendercode.ts
+async function renderRequest(request) {
+	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;
+	try {
+		body = await request.text();
+	} catch (_) {
+		body = "[Failed to decode body; it may be binary.]";
+	}
+	code += `\n${body}`;
+	return code;
+}
+async function renderResponse(response) {
+	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;
+	try {
+		body = await response.text();
+	} catch (_) {
+		body = "[Failed to decode body; it may be binary.]";
+	}
+	code += `\n${body}`;
+	return code;
+}
+async function renderRawActivity(request) {
+	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.]";
+	}
+}
+async function renderActivity(activity, expand = false) {
+	const contextLoader = await getContextLoader();
+	const jsonLd = await activity.toJsonLd({
+		contextLoader,
+		format: expand ? "expand" : "compact"
+	});
+	return JSON.stringify(jsonLd, null, 2);
+}
+function capitalize(name) {
+	return name.replace(/(^|-)./g, (match) => match.toUpperCase());
+}
+
+//#endregion
+export { renderActivity, renderRawActivity, renderRequest, renderResponse };