import { writeFileSync, mkdirSync, statSync } from "fs";
import { join } from "path";
import { randomUUID } from "crypto";
const STORAGE_DIR = "./generated-images";
const records: GenerationRecord[] = [];
async function generateAndPersist(
prompt: string,
options: {
model?: string;
style_type?: string;
aspect_ratio?: string;
negative_prompt?: string;
seed?: number;
tags?: string[];
} = {}
): Promise<GenerationRecord> {
const response = await fetch("https://api.ideogram.ai/generate", {
method: "POST",
headers: {
"Api-Key": process.env.IDEOGRAM_API_KEY!,
"Content-Type": "application/json",
},
body: JSON.stringify({
image_request: {
prompt,
model: options.model ?? "V_2",
style_type: options.style_type ?? "AUTO",
aspect_ratio: options.aspect_ratio ?? "ASPECT_1_1",
magic_prompt_option: "AUTO",
negative_prompt: options.negative_prompt,
seed: options.seed,
},
}),
});
if (!response.ok) throw new Error(`Generation failed: ${response.status}`);
const result = await response.json();
const image = result.data[0];
const imgResp = await fetch(image.url);
if (!imgResp.ok) throw new Error(`Download failed: ${imgResp.status}`);
const buffer = Buffer.from(await imgResp.arrayBuffer());
mkdirSync(STORAGE_DIR, { recursive: true });
const filename = `${image.seed}-${Date.now()}.png`;
const storedPath = join(STORAGE_DIR, filename);
writeFileSync(storedPath, buffer);
const record: GenerationRecord = {
id: randomUUID(),
prompt,
expandedPrompt: image.prompt !== prompt ? image.prompt : undefined,
negativePrompt: options.negative_prompt,
model: options.model ?? "V_2",
styleType: image.style_type ?? options.style_type ?? "AUTO",
aspectRatio: options.aspect_ratio ?? "ASPECT_1_1",
seed: image.seed,
resolution: image.resolution,
isSafe: image.is_image_safe,
originalUrl: image.url,
storedPath,
createdAt: new Date().toISOString(),
sizeBytes: buffer.length,
tags: options.tags,
};
records.push(record);
saveRecords();
return record;
}
function saveRecords() {
writeFileSync(
join(STORAGE_DIR, "generations.json"),
JSON.stringify(records, null, 2)
);
}
import { S3Client, PutObjectCommand, DeleteObjectCommand } from "@aws-sdk/client-s3";
const s3 = new S3Client({ region: process.env.AWS_REGION });
async function persistToS3(imageUrl: string, seed: number): Promise<string> {
const response = await fetch(imageUrl);
const buffer = Buffer.from(await response.arrayBuffer());
const key = `ideogram/${seed}-${Date.now()}.png`;
await s3.send(new PutObjectCommand({
Bucket: process.env.S3_BUCKET!,
Key: key,
Body: buffer,
ContentType: "image/png",
CacheControl: "public, max-age=31536000, immutable",
Metadata: { seed: String(seed), source: "ideogram" },
}));
return `https://${process.env.CDN_DOMAIN}/${key}`;
}
async function reproduceImage(record: GenerationRecord) {
return generateAndPersist(record.prompt, {
model: record.model,
style_type: record.styleType,
aspect_ratio: record.aspectRatio,
negative_prompt: record.negativePrompt,
seed: record.seed,
tags: [...(record.tags ?? []), "reproduced"],
});
}
import { unlinkSync, existsSync, readdirSync, statSync } from "fs";
function cleanupOldAssets(retentionDays: number = 30) {
const cutoffMs = Date.now() - retentionDays * 86400000;
let deleted = 0;
let kept = 0;
for (const record of records) {
const createdMs = new Date(record.createdAt).getTime();
if (createdMs < cutoffMs) {
if (existsSync(record.storedPath)) {
unlinkSync(record.storedPath);
deleted++;
}
} else {
kept++;
}
}
const activeRecords = records.filter(
r => new Date(r.createdAt).getTime() >= cutoffMs
);
records.length = 0;
records.push(...activeRecords);
saveRecords();
console.log(`Cleanup: deleted ${deleted}, kept ${kept}`);
}
function storageReport() {
const totalBytes = records.reduce((sum, r) => sum + (r.sizeBytes ?? 0), 0);
const byModel = Object.groupBy(records, r => r.model);
console.log("=== Image Storage Report ===");
console.log(`Total images: ${records.length}`);
console.log(`Total size: ${(totalBytes / 1024 / 1024).toFixed(1)} MB`);
for (const [model, recs] of Object.entries(byModel)) {
console.log(` ${model}: ${recs?.length ?? 0} images`);
}
}
function findByPrompt(searchTerm: string): GenerationRecord[] {
return records.filter(r =>
r.prompt.toLowerCase().includes(searchTerm.toLowerCase())
);
}
function findBySeed(seed: number): GenerationRecord | undefined {
return records.find(r => r.seed === seed);
}
function findByTags(tags: string[]): GenerationRecord[] {
return records.filter(r =>
tags.every(t => r.tags?.includes(t))
);
}
