const PER_LINE = 10;

const AVATAR_PROBE_SIZE = 40;

const AVATAR_PROBE_MAX_BYTES = 256 * 1024;

const AVATAR_PROBE_TIMEOUT_MS = 8000;

const AVATAR_SIZE = 48;

const CLAWTRIBUTORS_START = "<!-- clawtributors:start -->";

const CLAWTRIBUTORS_END = "<!-- clawtributors:end -->";

async function probeDefaultGitHubAvatar(login: string): Promise<boolean> {

try {

const response = await fetch(`https://github.com/${login}.png?size=${AVATAR_PROBE_SIZE}`, {

headers: { "user-agent": "openclaw-clawtributors" },

signal: AbortSignal.timeout(8000),

return await withAvatarProbeTimeout(login, async ({ signal, timeoutPromise }) => {

const response = await fetch(`https://github.com/${login}.png?size=${AVATAR_PROBE_SIZE}`, {

headers: { "user-agent": "openclaw-clawtributors" },

signal,

});

if (!response.ok) {

return false;

}

const buffer = await readAvatarProbeBuffer(response, timeoutPromise);

const dimensions = readImageDimensions(buffer);

return Boolean(

dimensions &&

(dimensions.width > AVATAR_PROBE_SIZE || dimensions.height > AVATAR_PROBE_SIZE),

);

});

if (!response.ok) {

return false;

}

const buffer = await readAvatarProbeBuffer(response);

const dimensions = readImageDimensions(buffer);

return Boolean(

dimensions && (dimensions.width > AVATAR_PROBE_SIZE || dimensions.height > AVATAR_PROBE_SIZE),

);

} catch {

return false;

}

}

async function readAvatarProbeBuffer(response: Response): Promise<Buffer> {

type AvatarProbeTimeout = {

signal: AbortSignal;

timeoutPromise: Promise<never>;

};

async function withAvatarProbeTimeout<T>(

login: string,

runProbe: (timeout: AvatarProbeTimeout) => Promise<T>,

): Promise<T> {

const controller = new AbortController();

let timeout: ReturnType<typeof setTimeout> | undefined;

const timeoutPromise = new Promise<never>((_resolve, reject) => {

timeout = setTimeout(() => {

const error = new Error(

`avatar probe for ${login} exceeded timeout of ${AVATAR_PROBE_TIMEOUT_MS}ms`,

);

reject(error);

controller.abort(error);

}, AVATAR_PROBE_TIMEOUT_MS);

});

try {

return await Promise.race([

runProbe({ signal: controller.signal, timeoutPromise }),

timeoutPromise,

]);

} finally {

if (timeout) {

clearTimeout(timeout);

}

}

}

function cancelAvatarProbeReaderSoon(reader: ReadableStreamDefaultReader<Uint8Array>): void {

void Promise.resolve()

.then(() => reader.cancel())

.catch(() => undefined);

}

function toAvatarProbeError(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

return new Error(fallbackMessage, { cause: value });

}

async function readAvatarProbeChunkWithTimeout(

reader: ReadableStreamDefaultReader<Uint8Array>,

timeoutPromise: Promise<never> | undefined,

markCanceled: () => void,

): Promise<ReadableStreamReadResult<Uint8Array>> {

const readPromise = reader.read();

if (!timeoutPromise) {

return await readPromise;

}

let waitingForRead = true;

const timeoutReadPromise = timeoutPromise.catch((error: unknown) => {

if (waitingForRead) {

markCanceled();

cancelAvatarProbeReaderSoon(reader);

}

throw toAvatarProbeError(error, "avatar probe response body read timed out");

});

try {

return await Promise.race([readPromise, timeoutReadPromise]);

} finally {

waitingForRead = false;

}

}

async function readAvatarProbeArrayBuffer(

response: Response,

timeoutPromise: Promise<never> | undefined,

): Promise<ArrayBuffer> {

if (!timeoutPromise) {

return await response.arrayBuffer();

}

return await Promise.race([

response.arrayBuffer(),

timeoutPromise.catch((error: unknown) => {

void response.body?.cancel().catch(() => undefined);

throw toAvatarProbeError(error, "avatar probe response body read timed out");

}),

]);

}

async function readAvatarProbeBuffer(

response: Response,

timeoutPromise?: Promise<never>,

): Promise<Buffer> {

const contentLength = Number(response.headers.get("content-length") ?? 0);

if (Number.isFinite(contentLength) && contentLength > AVATAR_PROBE_MAX_BYTES) {

await response.body?.cancel().catch(() => undefined);

throw new Error(`avatar probe exceeded ${AVATAR_PROBE_MAX_BYTES} bytes`);

}

const reader = response.body?.getReader?.();

if (!reader) {

const buffer = Buffer.from(await response.arrayBuffer());

const buffer = Buffer.from(await readAvatarProbeArrayBuffer(response, timeoutPromise));

if (buffer.byteLength > AVATAR_PROBE_MAX_BYTES) {

throw new Error(`avatar probe exceeded ${AVATAR_PROBE_MAX_BYTES} bytes`);

}

const chunks: Buffer[] = [];

let total = 0;

for (;;) {

const { done, value } = await reader.read();

if (done) {

break;

}

if (!value?.byteLength) {

continue;

let canceled = false;

try {

for (;;) {

const { done, value } = await readAvatarProbeChunkWithTimeout(reader, timeoutPromise, () => {

canceled = true;

});

if (done) {

break;

}

if (!value?.byteLength) {

continue;

}

const chunk = Buffer.from(value);

const nextTotal = total + chunk.byteLength;

if (nextTotal > AVATAR_PROBE_MAX_BYTES) {

canceled = true;

await reader.cancel().catch(() => undefined);

throw new Error(`avatar probe exceeded ${AVATAR_PROBE_MAX_BYTES} bytes`);

}

chunks.push(chunk);

total = nextTotal;

}

const chunk = Buffer.from(value);

const nextTotal = total + chunk.byteLength;

if (nextTotal > AVATAR_PROBE_MAX_BYTES) {

await reader.cancel().catch(() => undefined);

throw new Error(`avatar probe exceeded ${AVATAR_PROBE_MAX_BYTES} bytes`);

} finally {

if (!canceled) {

reader.releaseLock();

}

chunks.push(chunk);

total = nextTotal;

}

return Buffer.concat(chunks, total);

}