mirror of
https://github.com/openclaw/openclaw.git
synced 2026-05-25 09:43:03 +00:00
399 lines
12 KiB
JavaScript
Executable File
399 lines
12 KiB
JavaScript
Executable File
#!/usr/bin/env node
|
|
import { Buffer } from "node:buffer";
|
|
import { existsSync } from "node:fs";
|
|
import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
|
|
import { homedir } from "node:os";
|
|
import path from "node:path";
|
|
import { fileURLToPath } from "node:url";
|
|
|
|
const BASE_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
|
|
const TEMPLATES_PATH = path.join(BASE_DIR, "references", "templates.json");
|
|
const IMGFLIP_GET_MEMES_URL = "https://api.imgflip.com/get_memes";
|
|
const IMGFLIP_CAPTION_URL = "https://api.imgflip.com/caption_image";
|
|
const USER_AGENT = "OpenClawMemeMaker/1.0";
|
|
const STOPWORDS = new Set([
|
|
"a",
|
|
"an",
|
|
"and",
|
|
"are",
|
|
"for",
|
|
"in",
|
|
"is",
|
|
"it",
|
|
"of",
|
|
"on",
|
|
"or",
|
|
"the",
|
|
"this",
|
|
"to",
|
|
"use",
|
|
"with",
|
|
]);
|
|
|
|
function usage(exitCode = 0) {
|
|
const out = exitCode === 0 ? console.log : console.error;
|
|
out(`Usage:
|
|
meme.mjs list [--json]
|
|
meme.mjs search <query> [--json]
|
|
meme.mjs suggest <topic> [--limit N] [--json]
|
|
meme.mjs render <template> --text TEXT ... [--out PATH] [--service local|imgflip]
|
|
meme.mjs refresh [--limit N] [--json]`);
|
|
process.exit(exitCode);
|
|
}
|
|
|
|
function parseArgs(argv) {
|
|
const flags = { _: [] };
|
|
for (let i = 0; i < argv.length; i += 1) {
|
|
const arg = argv[i];
|
|
if (!arg.startsWith("--")) {
|
|
flags._.push(arg);
|
|
continue;
|
|
}
|
|
const eq = arg.indexOf("=");
|
|
const key = eq === -1 ? arg.slice(2) : arg.slice(2, eq);
|
|
const inline = eq === -1 ? undefined : arg.slice(eq + 1);
|
|
if (["json", "help"].includes(key)) {
|
|
flags[key] = true;
|
|
continue;
|
|
}
|
|
const value = inline ?? argv[i + 1];
|
|
if (inline === undefined) i += 1;
|
|
if (value === undefined) throw new Error(`Missing value for --${key}`);
|
|
if (key === "text") {
|
|
flags.text = [...(flags.text ?? []), value];
|
|
} else {
|
|
flags[key] = value;
|
|
}
|
|
}
|
|
return flags;
|
|
}
|
|
|
|
function normalize(value) {
|
|
return String(value)
|
|
.toLowerCase()
|
|
.replace(/[^a-z0-9]+/g, " ")
|
|
.trim();
|
|
}
|
|
|
|
function tokens(value) {
|
|
return normalize(value)
|
|
.split(/\s+/)
|
|
.filter((token) => token && !STOPWORDS.has(token));
|
|
}
|
|
|
|
async function loadTemplates() {
|
|
return JSON.parse(await readFile(TEMPLATES_PATH, "utf8"));
|
|
}
|
|
|
|
function templateHaystack(template) {
|
|
return [
|
|
template.id,
|
|
template.name,
|
|
template.use,
|
|
...(template.aliases ?? []),
|
|
...(template.tags ?? []),
|
|
...(template.fields ?? []),
|
|
].join(" ");
|
|
}
|
|
|
|
function scoreTemplate(template, query) {
|
|
const queryTokens = tokens(query);
|
|
const haystack = normalize(templateHaystack(template));
|
|
let score = 0;
|
|
for (const token of queryTokens) {
|
|
if (normalize(template.id).includes(token)) score += 8;
|
|
if (normalize(template.name).includes(token)) score += 6;
|
|
if ((template.aliases ?? []).some((alias) => normalize(alias).includes(token))) score += 5;
|
|
if ((template.tags ?? []).some((tag) => normalize(tag).includes(token))) score += 4;
|
|
if (normalize(template.use).includes(token)) score += 3;
|
|
if (haystack.includes(token)) score += 1;
|
|
}
|
|
return score;
|
|
}
|
|
|
|
function findTemplate(templates, selector) {
|
|
const wanted = normalize(selector);
|
|
const exact = templates.find(
|
|
(template) =>
|
|
normalize(template.id) === wanted ||
|
|
normalize(template.name) === wanted ||
|
|
(template.aliases ?? []).some((alias) => normalize(alias) === wanted),
|
|
);
|
|
if (exact) return exact;
|
|
const ranked = templates
|
|
.map((template) => ({ template, score: scoreTemplate(template, selector) }))
|
|
.filter((entry) => entry.score > 0)
|
|
.sort((a, b) => b.score - a.score);
|
|
return ranked[0]?.template;
|
|
}
|
|
|
|
function printTemplates(templates, json) {
|
|
if (json) {
|
|
console.log(JSON.stringify(templates, null, 2));
|
|
return;
|
|
}
|
|
for (const template of templates) {
|
|
console.log(`${template.id}: ${template.name}`);
|
|
console.log(` use: ${template.use}`);
|
|
console.log(` fields: ${template.fields.join(", ")}`);
|
|
console.log(` kym: ${template.kymUrl}`);
|
|
}
|
|
}
|
|
|
|
function cacheRoot() {
|
|
const root =
|
|
process.env.XDG_CACHE_HOME ||
|
|
(process.platform === "darwin"
|
|
? path.join(homedir(), "Library", "Caches")
|
|
: path.join(homedir(), ".cache"));
|
|
return path.join(root, "openclaw", "meme-maker");
|
|
}
|
|
|
|
function extFromUrl(url) {
|
|
const ext = path.extname(new URL(url).pathname).toLowerCase();
|
|
return ext && ext.length <= 5 ? ext : ".img";
|
|
}
|
|
|
|
async function fetchBuffer(url) {
|
|
const response = await fetch(url, { headers: { "User-Agent": USER_AGENT } });
|
|
if (!response.ok) throw new Error(`Fetch failed ${response.status} for ${url}`);
|
|
return Buffer.from(await response.arrayBuffer());
|
|
}
|
|
|
|
async function cachedTemplateImage(template) {
|
|
const dir = cacheRoot();
|
|
await mkdir(dir, { recursive: true });
|
|
const file = path.join(
|
|
dir,
|
|
`${template.id}-${template.imgflipId}${extFromUrl(template.imageUrl)}`,
|
|
);
|
|
if (existsSync(file)) return { file, buffer: await readFile(file) };
|
|
const buffer = await fetchBuffer(template.imageUrl);
|
|
await writeFile(file, buffer);
|
|
return { file, buffer };
|
|
}
|
|
|
|
function escapeXml(value) {
|
|
return String(value)
|
|
.replaceAll("&", "&")
|
|
.replaceAll("<", "<")
|
|
.replaceAll(">", ">")
|
|
.replaceAll('"', """);
|
|
}
|
|
|
|
function wrapText(text, maxChars) {
|
|
const words = String(text).trim().split(/\s+/).filter(Boolean);
|
|
const lines = [];
|
|
let current = "";
|
|
for (const word of words) {
|
|
const candidate = current ? `${current} ${word}` : word;
|
|
if (candidate.length <= maxChars || !current) {
|
|
current = candidate;
|
|
} else {
|
|
lines.push(current);
|
|
current = word;
|
|
}
|
|
}
|
|
if (current) lines.push(current);
|
|
return lines.length ? lines : [""];
|
|
}
|
|
|
|
function textSvg(text, box, width, height, index) {
|
|
const x = box.x * width;
|
|
const y = box.y * height;
|
|
const w = box.w * width;
|
|
const h = box.h * height;
|
|
const centerX = x + w / 2;
|
|
const centerY = y + h / 2;
|
|
const maxChars = Math.max(8, Math.floor(w / Math.max(12, width * 0.032)));
|
|
let lines = wrapText(text, maxChars).slice(0, 5);
|
|
const fontSize = Math.max(
|
|
18,
|
|
Math.min(
|
|
h / (lines.length * 1.15),
|
|
(w / Math.max(...lines.map((line) => line.length), 1)) * 1.65,
|
|
width * 0.07,
|
|
),
|
|
);
|
|
const lineHeight = fontSize * 1.08;
|
|
const totalHeight = lineHeight * lines.length;
|
|
const rotate = box.rotate ? ` rotate(${box.rotate} ${centerX} ${centerY})` : "";
|
|
lines = lines.map(escapeXml);
|
|
const tspans = lines
|
|
.map((line, lineIndex) => {
|
|
const dy = lineIndex === 0 ? -(totalHeight - lineHeight) / 2 : lineHeight;
|
|
return `<tspan x="${centerX.toFixed(1)}" dy="${dy.toFixed(1)}">${line}</tspan>`;
|
|
})
|
|
.join("");
|
|
return `<text class="meme-text" data-box="${index}" transform="translate(0 ${centerY.toFixed(1)})${rotate}" font-size="${fontSize.toFixed(1)}">${tspans}</text>`;
|
|
}
|
|
|
|
function defaultBoxes(count) {
|
|
if (count <= 1) return [{ x: 0.06, y: 0.74, w: 0.88, h: 0.18 }];
|
|
if (count === 2) {
|
|
return [
|
|
{ x: 0.06, y: 0.05, w: 0.88, h: 0.18 },
|
|
{ x: 0.06, y: 0.76, w: 0.88, h: 0.18 },
|
|
];
|
|
}
|
|
return Array.from({ length: count }, (_, index) => ({
|
|
x: 0.05,
|
|
y: 0.04 + index * (0.9 / count),
|
|
w: 0.9,
|
|
h: Math.min(0.16, 0.8 / count),
|
|
}));
|
|
}
|
|
|
|
async function renderLocal(template, texts, flags) {
|
|
const { buffer } = await cachedTemplateImage(template);
|
|
const imageMime = extFromUrl(template.imageUrl) === ".png" ? "image/png" : "image/jpeg";
|
|
const imageData = `data:${imageMime};base64,${buffer.toString("base64")}`;
|
|
const boxes = template.boxes?.length
|
|
? template.boxes
|
|
: defaultBoxes(texts.length || template.fields.length);
|
|
const width = Number(template.width);
|
|
const height = Number(template.height);
|
|
const textNodes = texts
|
|
.map((text, index) =>
|
|
textSvg(text, boxes[index] ?? boxes[boxes.length - 1], width, height, index),
|
|
)
|
|
.join("\n");
|
|
const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">
|
|
<style>
|
|
.meme-text {
|
|
font-family: Impact, "Arial Black", Arial, sans-serif;
|
|
font-weight: 900;
|
|
fill: #fff;
|
|
stroke: #000;
|
|
stroke-width: ${Math.max(3, Math.round(width / 250))};
|
|
paint-order: stroke;
|
|
text-anchor: middle;
|
|
dominant-baseline: middle;
|
|
letter-spacing: 0;
|
|
}
|
|
</style>
|
|
<image href="${imageData}" x="0" y="0" width="${width}" height="${height}" preserveAspectRatio="none"/>
|
|
${textNodes}
|
|
</svg>
|
|
`;
|
|
const out = flags.out ?? path.resolve(process.cwd(), `${template.id}.svg`);
|
|
await mkdir(path.dirname(path.resolve(out)), { recursive: true });
|
|
if (path.extname(out).toLowerCase() === ".png") {
|
|
let sharp;
|
|
try {
|
|
sharp = (await import("sharp")).default;
|
|
} catch {
|
|
throw new Error(
|
|
"PNG output needs the optional sharp package. Use --out meme.svg or install sharp near the skill runner.",
|
|
);
|
|
}
|
|
await sharp(Buffer.from(svg)).png().toFile(out);
|
|
} else {
|
|
await writeFile(out, svg, "utf8");
|
|
}
|
|
const size = (await stat(out)).size;
|
|
console.log(`${out} (${size} bytes)`);
|
|
}
|
|
|
|
async function renderImgflip(template, texts, flags) {
|
|
const username = flags.username || process.env.IMGFLIP_USER;
|
|
const password = flags.password || process.env.IMGFLIP_PASS;
|
|
if (!username || !password) {
|
|
throw new Error(
|
|
"Imgflip service requires IMGFLIP_USER and IMGFLIP_PASS, or --username/--password.",
|
|
);
|
|
}
|
|
const body = new URLSearchParams({
|
|
template_id: template.imgflipId,
|
|
username,
|
|
password,
|
|
});
|
|
if ((template.boxes?.length ?? template.fields.length) <= 2) {
|
|
texts.forEach((text, index) => body.set(`text${index}`, text));
|
|
} else {
|
|
texts.forEach((text, index) => body.set(`boxes[${index}][text]`, text));
|
|
}
|
|
const response = await fetch(IMGFLIP_CAPTION_URL, {
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/x-www-form-urlencoded",
|
|
"User-Agent": USER_AGENT,
|
|
},
|
|
body,
|
|
});
|
|
const payload = await response.json();
|
|
if (!payload.success) throw new Error(payload.error_message || "Imgflip caption_image failed");
|
|
console.log(payload.data.url);
|
|
}
|
|
|
|
async function refresh(flags) {
|
|
const limit = Number(flags.limit || 25);
|
|
const response = await fetch(IMGFLIP_GET_MEMES_URL, { headers: { "User-Agent": USER_AGENT } });
|
|
if (!response.ok) throw new Error(`Imgflip get_memes failed ${response.status}`);
|
|
const payload = await response.json();
|
|
const memes = payload.data.memes.slice(0, limit);
|
|
if (flags.json) {
|
|
console.log(JSON.stringify(memes, null, 2));
|
|
} else {
|
|
for (const meme of memes) {
|
|
console.log(
|
|
`${meme.id}: ${meme.name} (${meme.width}x${meme.height}, boxes=${meme.box_count})`,
|
|
);
|
|
console.log(` ${meme.url}`);
|
|
}
|
|
}
|
|
}
|
|
|
|
async function main() {
|
|
const flags = parseArgs(process.argv.slice(2));
|
|
if (flags.help) usage(0);
|
|
const [command, ...rest] = flags._;
|
|
if (!command) usage(1);
|
|
const templates = await loadTemplates();
|
|
|
|
if (command === "list") {
|
|
printTemplates(templates, flags.json);
|
|
return;
|
|
}
|
|
if (command === "search" || command === "suggest") {
|
|
const query = rest.join(" ");
|
|
if (!query) throw new Error(`${command} needs a query`);
|
|
const limit = Number(flags.limit || (command === "suggest" ? 5 : 20));
|
|
const ranked = templates
|
|
.map((template) => ({ ...template, score: scoreTemplate(template, query) }))
|
|
.filter((template) => template.score > 0)
|
|
.sort((a, b) => b.score - a.score)
|
|
.slice(0, limit);
|
|
printTemplates(ranked, flags.json);
|
|
return;
|
|
}
|
|
if (command === "render") {
|
|
const selector = rest.join(" ");
|
|
if (!selector) throw new Error("render needs a template id/name");
|
|
const template = findTemplate(templates, selector);
|
|
if (!template) throw new Error(`No matching template: ${selector}`);
|
|
const texts = flags.text ?? [];
|
|
if (!texts.length)
|
|
throw new Error(`Add text with --text. Fields: ${template.fields.join(", ")}`);
|
|
const service = flags.service || "local";
|
|
if (service === "local") {
|
|
await renderLocal(template, texts, flags);
|
|
} else if (service === "imgflip") {
|
|
await renderImgflip(template, texts, flags);
|
|
} else {
|
|
throw new Error(`Unknown service: ${service}`);
|
|
}
|
|
return;
|
|
}
|
|
if (command === "refresh") {
|
|
await refresh(flags);
|
|
return;
|
|
}
|
|
usage(1);
|
|
}
|
|
|
|
main().catch((error) => {
|
|
console.error(`error: ${error.message}`);
|
|
process.exit(1);
|
|
});
|