1import { createHash } from "node:crypto";
2import { mkdir, readFile, writeFile, copyFile, stat } from "node:fs/promises";
3import { existsSync, openSync, closeSync } from "node:fs";
4import path from "node:path";
5import { setTimeout as delay } from "node:timers/promises";
6 
7export function cacheKey(prompt: string, aspect: string, refs: string[]): string {
8  const h = createHash("sha256");
9  h.update(prompt);
10  h.update("|");
11  h.update(aspect);
12  h.update("|");
13  for (const r of [...refs].sort()) h.update(r);
14  return h.digest("hex").slice(0, 16);
15}
16 
17export async function lookupCache(cacheDir: string, key: string): Promise<string | null> {
18  const entry = path.join(cacheDir, `${key}.png`);
19  try {
20    const s = await stat(entry);
21    if (s.size > 1000) return entry;
22  } catch {}
23  return null;
24}
25 
26export async function storeCache(cacheDir: string, key: string, sourcePath: string): Promise<void> {
27  await mkdir(cacheDir, { recursive: true });
28  const entry = path.join(cacheDir, `${key}.png`);
29  await copyFile(sourcePath, entry);
30}
31 
32export class FileLock {
33  private fd: number | null = null;
34  constructor(private lockPath: string) {}
35 
36  async acquire(timeoutMs = 30_000): Promise<void> {
37    const start = Date.now();
38    await mkdir(path.dirname(this.lockPath), { recursive: true });
39    while (Date.now() - start < timeoutMs) {
40      try {
41        this.fd = openSync(this.lockPath, "wx");
42        return;
43      } catch (e: any) {
44        if (e.code !== "EEXIST") throw e;
45        if (await this.isStale()) {
46          try {
47            await this.release(true);
48          } catch {}
49          continue;
50        }
51        await delay(200);
52      }
53    }
54    throw new Error(`Failed to acquire lock at ${this.lockPath} within ${timeoutMs}ms`);
55  }
56 
57  private async isStale(): Promise<boolean> {
58    try {
59      const s = await stat(this.lockPath);
60      return Date.now() - s.mtimeMs > 10 * 60 * 1000;
61    } catch {
62      return true;
63    }
64  }
65 
66  async release(force = false): Promise<void> {
67    if (this.fd != null) {
68      try {
69        closeSync(this.fd);
70      } catch {}
71      this.fd = null;
72    }
73    if (existsSync(this.lockPath) || force) {
74      const { unlink } = await import("node:fs/promises");
75      try {
76        await unlink(this.lockPath);
77      } catch {}
78    }
79  }
80}
81