@fedify/cli 1.8.12 → 2.0.0-dev.1761

package/src/imagerenderer.ts

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

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

@@ -0,0 +1,68 @@
+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());
+}