sneakoscope 8.2.0 → 8.3.0

package/dist/core/telegram/poller.js

@@ -1,90 +0,0 @@
-import { TelegramApiError } from './client.js';
-import { redactTelegramError } from './redaction.js';
-export class TelegramPoller {
-    options;
-    controller = null;
-    state = {
-        schema: 'sks.telegram-poller-state.v1', running: false, offset: 0,
-        consecutive_failures: 0, last_poll_at: null, last_success_at: null,
-        last_update_at: null, last_error: null
-    };
-    constructor(options) {
-        this.options = {
-            ...options,
-            timeoutSeconds: Math.max(1, Math.min(options.timeoutSeconds ?? 30, 50)),
-            minBackoffMs: Math.max(100, options.minBackoffMs ?? 500),
-            maxBackoffMs: Math.max(options.minBackoffMs ?? 500, Math.min(options.maxBackoffMs ?? 30_000, 60_000)),
-            initialOffset: Number.isSafeInteger(options.initialOffset) && Number(options.initialOffset) >= 0
-                ? Number(options.initialOffset)
-                : 0,
-            sleep: options.sleep ?? abortableSleep
-        };
-        this.state = { ...this.state, offset: this.options.initialOffset };
-    }
-    snapshot() { return { ...this.state }; }
-    start() {
-        if (this.controller)
-            throw new Error('telegram_poller_already_running');
-        this.controller = new AbortController();
-        this.state = { ...this.state, running: true, last_error: null };
-        return this.run(this.controller.signal).finally(() => {
-            this.controller = null;
-            this.state = { ...this.state, running: false };
-        });
-    }
-    stop() { this.controller?.abort(); }
-    async run(signal) {
-        while (!signal.aborted) {
-            this.state = { ...this.state, last_poll_at: new Date().toISOString() };
-            try {
-                const updates = await this.options.client.getUpdates({
-                    offset: this.state.offset,
-                    timeoutSeconds: this.options.timeoutSeconds,
-                    allowedUpdates: ['message'],
-                    signal
-                });
-                for (const update of [...updates].sort((a, b) => a.update_id - b.update_id)) {
-                    if (signal.aborted)
-                        return;
-                    if (!Number.isSafeInteger(update.update_id) || update.update_id < this.state.offset)
-                        continue;
-                    const claimed = {
-                        ...this.state,
-                        offset: Math.max(this.state.offset, update.update_id + 1),
-                        last_update_at: new Date().toISOString()
-                    };
-                    if (this.options.checkpoint)
-                        await this.options.checkpoint(claimed);
-                    this.state = claimed;
-                    await this.options.handleUpdate(update);
-                }
-                this.state = {
-                    ...this.state,
-                    consecutive_failures: 0,
-                    last_success_at: new Date().toISOString(),
-                    last_error: null
-                };
-            }
-            catch (error) {
-                if (signal.aborted)
-                    return;
-                const failures = this.state.consecutive_failures + 1;
-                this.state = { ...this.state, consecutive_failures: failures, last_error: redactTelegramError(error) };
-                const retryAfter = error instanceof TelegramApiError ? error.retryAfterSeconds : null;
-                const exponential = Math.min(this.options.maxBackoffMs, this.options.minBackoffMs * (2 ** Math.min(failures - 1, 8)));
-                const delay = retryAfter == null ? exponential : Math.min(this.options.maxBackoffMs, Math.max(exponential, retryAfter * 1_000));
-                await this.options.sleep(delay, signal).catch(() => undefined);
-            }
-        }
-    }
-}
-function abortableSleep(ms, signal) {
-    return new Promise((resolve, reject) => {
-        if (signal.aborted)
-            return reject(signal.reason);
-        const timer = setTimeout(done, ms);
-        signal.addEventListener('abort', aborted, { once: true });
-        function done() { signal.removeEventListener('abort', aborted); resolve(); }
-        function aborted() { clearTimeout(timer); reject(signal.reason); }
-    });
-}

package/dist/core/telegram/redaction.js

@@ -1,15 +0,0 @@
-import { createHash } from 'node:crypto';
-const BOT_URL = /\/bot[^/\s]+\//gi;
-const TOKEN_ASSIGNMENT = /((?:bot[_-]?token|token)\s*[:=]\s*)[^\s,"'}]+/gi;
-export function redactTelegramError(value, token) {
-    let text = value instanceof Error ? value.message : String(value ?? 'telegram_error');
-    if (token)
-        text = text.split(token).join('[redacted]');
-    return text
-        .replace(BOT_URL, '/bot[redacted]/')
-        .replace(TOKEN_ASSIGNMENT, '$1[redacted]')
-        .slice(0, 512);
-}
-export function redactedChatActor(chatId, senderId = chatId) {
-    return `actor:${createHash('sha256').update(`${chatId}:${senderId}`).digest('hex').slice(0, 12)}`;
-}

package/dist/core/telegram/state-lock.js

@@ -1,416 +0,0 @@
-import fs from 'node:fs/promises';
-import { constants as fsConstants } from 'node:fs';
-import path from 'node:path';
-import { randomUUID } from 'node:crypto';
-import { spawnSync } from 'node:child_process';
-import { assertTestHomeWriteAllowed } from '../fsx.js';
-const LOCK_SCHEMA = 'sks.telegram-lock.v1';
-const LOCK_MAX_BYTES = 4096;
-const LOCK_ATTEMPTS = 200;
-const LOCK_RETRY_MS = 25;
-const LOCK_TOKEN_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-export async function withTelegramStateLock(paths, operation) {
-    const identity = await acquireStateLock(paths);
-    try {
-        return await operation();
-    }
-    finally {
-        await releaseStateLock(paths.stateLockPath, identity);
-    }
-}
-async function acquireStateLock(paths) {
-    assertTestHomeWriteAllowed(paths.stateLockPath);
-    const candidate = await createOwnerCandidate(paths.stateDir, '.telegram.lock');
-    let published = false;
-    try {
-        for (let attempt = 0; attempt < LOCK_ATTEMPTS; attempt += 1) {
-            if (await reclaimBarrierExists(paths)) {
-                await settleReclaimBarrier(paths);
-                await retryDelay(attempt);
-                continue;
-            }
-            try {
-                await fs.link(candidate.path, paths.stateLockPath);
-                published = true;
-                const acquired = await inspectOwnerFile(paths.stateLockPath, 'lock');
-                if (!sameIdentity(acquired, candidate.identity)) {
-                    throw new Error('telegram_state_lock_publish_identity_mismatch');
-                }
-                if (await reclaimBarrierExists(paths)) {
-                    await releaseStateLock(paths.stateLockPath, candidate.identity);
-                    published = false;
-                    await settleReclaimBarrier(paths);
-                    await retryDelay(attempt);
-                    continue;
-                }
-                await fs.unlink(candidate.path);
-                published = false;
-                return candidate.identity;
-            }
-            catch (error) {
-                if (error?.code !== 'EEXIST')
-                    throw error;
-                const existing = await inspectOwnerFile(paths.stateLockPath, 'lock').catch((inspectionError) => {
-                    if (isTransientLockInspection(inspectionError))
-                        return null;
-                    throw inspectionError;
-                });
-                if (existing && ownerIsDead(existing.owner)) {
-                    if (await reclaimDeadStateLock(paths, existing))
-                        continue;
-                }
-            }
-            await retryDelay(attempt);
-        }
-        throw new Error('telegram_state_lock_timeout');
-    }
-    finally {
-        await fs.unlink(candidate.path).catch(() => undefined);
-        if (published)
-            await releaseStateLock(paths.stateLockPath, candidate.identity);
-    }
-}
-async function retryDelay(attempt) {
-    if (attempt + 1 >= LOCK_ATTEMPTS)
-        return;
-    await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_MS));
-}
-async function reclaimDeadStateLock(paths, expected) {
-    const participant = await joinReclaimBarrier(paths);
-    try {
-        await cleanupDeadParticipants(paths);
-        const current = await inspectOwnerFile(paths.stateLockPath, 'lock').catch((error) => {
-            if (isTransientLockInspection(error))
-                return null;
-            throw error;
-        });
-        if (!current || !sameInspectedLock(current, expected) || !ownerIsDead(current.owner))
-            return false;
-        try {
-            await fs.unlink(paths.stateLockPath);
-            return true;
-        }
-        catch (error) {
-            if (error?.code === 'ENOENT')
-                return false;
-            throw error;
-        }
-    }
-    finally {
-        await leaveReclaimBarrier(paths, participant);
-    }
-}
-async function settleReclaimBarrier(paths) {
-    const participant = await joinReclaimBarrier(paths);
-    try {
-        await cleanupDeadParticipants(paths);
-        const current = await inspectOwnerFile(paths.stateLockPath, 'lock').catch((error) => {
-            if (isTransientLockInspection(error))
-                return null;
-            throw error;
-        });
-        if (current && ownerIsDead(current.owner)) {
-            await fs.unlink(paths.stateLockPath).catch((error) => {
-                if (error?.code !== 'ENOENT')
-                    throw error;
-            });
-        }
-    }
-    finally {
-        await leaveReclaimBarrier(paths, participant);
-    }
-}
-async function joinReclaimBarrier(paths) {
-    const candidate = await createOwnerCandidate(paths.stateDir, '.telegram.reclaim');
-    const barrierPath = reclaimBarrierPath(paths);
-    const participantPath = path.join(barrierPath, `.owner.${candidate.identity.pid}.${candidate.identity.token}`);
-    try {
-        for (let attempt = 0; attempt < LOCK_ATTEMPTS; attempt += 1) {
-            await ensureReclaimBarrier(paths);
-            try {
-                await fs.link(candidate.path, participantPath);
-                const inspected = await inspectOwnerFile(participantPath, 'reclaim');
-                if (!sameIdentity(inspected, candidate.identity)) {
-                    throw new Error('telegram_state_reclaim_participant_identity_mismatch');
-                }
-                await fs.unlink(candidate.path);
-                return { ...candidate.identity, path: participantPath };
-            }
-            catch (error) {
-                const code = error?.code;
-                if (code !== 'ENOENT' && code !== 'EEXIST' && code !== 'EINVAL')
-                    throw error;
-            }
-            await retryDelay(attempt);
-        }
-        throw new Error('telegram_state_reclaim_barrier_timeout');
-    }
-    finally {
-        await fs.unlink(candidate.path).catch(() => undefined);
-    }
-}
-async function leaveReclaimBarrier(paths, participant) {
-    await unlinkOwnedFile(participant.path, participant, 'reclaim');
-    await cleanupDeadParticipants(paths);
-    await fs.rmdir(reclaimBarrierPath(paths)).catch((error) => {
-        const code = error?.code;
-        if (code !== 'ENOENT' && code !== 'ENOTEMPTY' && code !== 'EEXIST')
-            throw error;
-    });
-}
-async function cleanupDeadParticipants(paths) {
-    const barrierPath = reclaimBarrierPath(paths);
-    let entries;
-    try {
-        entries = await fs.readdir(barrierPath, { withFileTypes: true });
-    }
-    catch (error) {
-        if (error?.code === 'ENOENT')
-            return;
-        throw error;
-    }
-    for (const entry of entries) {
-        if (!entry.isFile() || entry.isSymbolicLink()) {
-            throw new Error('telegram_state_reclaim_participant_unsafe_type');
-        }
-        const participantPath = path.join(barrierPath, entry.name);
-        const inspected = await inspectOwnerFile(participantPath, 'reclaim').catch((error) => {
-            if (error?.code === 'ENOENT')
-                return null;
-            throw error;
-        });
-        if (!inspected)
-            continue;
-        if (entry.name !== `.owner.${inspected.owner.pid}.${inspected.owner.token}`) {
-            throw new Error('telegram_state_reclaim_participant_name_mismatch');
-        }
-        if (ownerIsDead(inspected.owner)) {
-            await unlinkOwnedFile(participantPath, {
-                dev: inspected.dev,
-                ino: inspected.ino,
-                pid: inspected.owner.pid,
-                token: inspected.owner.token
-            }, 'reclaim');
-        }
-    }
-}
-async function ensureReclaimBarrier(paths) {
-    const barrierPath = reclaimBarrierPath(paths);
-    assertTestHomeWriteAllowed(barrierPath);
-    for (let attempt = 0; attempt < LOCK_ATTEMPTS; attempt += 1) {
-        try {
-            await fs.mkdir(barrierPath, { mode: 0o700 });
-        }
-        catch (error) {
-            if (error?.code !== 'EEXIST')
-                throw error;
-        }
-        if (await inspectReclaimBarrier(barrierPath))
-            return;
-        await retryDelay(attempt);
-    }
-    throw new Error('telegram_state_reclaim_barrier_timeout');
-}
-async function reclaimBarrierExists(paths) {
-    return inspectReclaimBarrier(reclaimBarrierPath(paths));
-}
-async function inspectReclaimBarrier(barrierPath) {
-    const pathStat = await fs.lstat(barrierPath).catch((error) => {
-        if (error?.code === 'ENOENT')
-            return null;
-        throw error;
-    });
-    if (!pathStat)
-        return false;
-    if (pathStat.isSymbolicLink() || !pathStat.isDirectory()) {
-        throw new Error('telegram_state_reclaim_barrier_unsafe_type');
-    }
-    if ((pathStat.mode & 0o777) !== 0o700)
-        throw new Error('telegram_state_reclaim_barrier_mode_not_0700');
-    const expectedUid = typeof process.getuid === 'function' ? process.getuid() : null;
-    if (expectedUid !== null && pathStat.uid !== expectedUid) {
-        throw new Error('telegram_state_reclaim_barrier_owner_mismatch');
-    }
-    const handle = await fs.open(barrierPath, fsConstants.O_RDONLY | fsConstants.O_DIRECTORY | fsConstants.O_NOFOLLOW).catch((error) => {
-        if (error?.code === 'ENOENT')
-            return null;
-        throw error;
-    });
-    if (!handle)
-        return false;
-    try {
-        const stat = await handle.stat();
-        if (!stat.isDirectory())
-            throw new Error('telegram_state_reclaim_barrier_unsafe_type');
-        if ((stat.mode & 0o777) !== 0o700)
-            throw new Error('telegram_state_reclaim_barrier_mode_not_0700');
-        if (expectedUid !== null && stat.uid !== expectedUid) {
-            throw new Error('telegram_state_reclaim_barrier_owner_mismatch');
-        }
-        if (stat.dev !== pathStat.dev || stat.ino !== pathStat.ino)
-            return false;
-    }
-    finally {
-        await handle.close();
-    }
-    return true;
-}
-function reclaimBarrierPath(paths) {
-    return `${paths.stateLockPath}.reclaim`;
-}
-async function createOwnerCandidate(stateDir, prefix) {
-    const token = randomUUID();
-    const owner = {
-        schema: LOCK_SCHEMA,
-        pid: process.pid,
-        token,
-        process_start_seconds: readProcessStartSeconds(process.pid)
-    };
-    const candidatePath = path.join(stateDir, `${prefix}.${process.pid}.${token}.tmp`);
-    assertTestHomeWriteAllowed(candidatePath);
-    const handle = await fs.open(candidatePath, fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL | fsConstants.O_NOFOLLOW, 0o600);
-    let closed = false;
-    try {
-        await handle.chmod(0o600);
-        await handle.writeFile(`${JSON.stringify(owner)}\n`, 'utf8');
-        await handle.sync();
-        const stat = await handle.stat();
-        if (!stat.isFile() || (stat.mode & 0o777) !== 0o600)
-            throw new Error('telegram_state_lock_candidate_unsafe');
-        const expectedUid = typeof process.getuid === 'function' ? process.getuid() : null;
-        if (expectedUid !== null && stat.uid !== expectedUid) {
-            throw new Error('telegram_state_lock_candidate_owner_mismatch');
-        }
-        await handle.close();
-        closed = true;
-        return { path: candidatePath, identity: { dev: stat.dev, ino: stat.ino, pid: process.pid, token } };
-    }
-    catch (error) {
-        if (!closed)
-            await handle.close().catch(() => undefined);
-        await fs.unlink(candidatePath).catch(() => undefined);
-        throw error;
-    }
-}
-async function inspectOwnerFile(file, kind) {
-    const prefix = kind === 'lock' ? 'telegram_state_lock' : 'telegram_state_reclaim_participant';
-    const pathStat = await fs.lstat(file);
-    if (pathStat.isSymbolicLink() || !pathStat.isFile())
-        throw new Error(`${prefix}_unsafe_type`);
-    if ((pathStat.mode & 0o777) !== 0o600)
-        throw new Error(`${prefix}_mode_not_0600`);
-    const expectedUid = typeof process.getuid === 'function' ? process.getuid() : null;
-    if (expectedUid !== null && pathStat.uid !== expectedUid)
-        throw new Error(`${prefix}_owner_mismatch`);
-    if (pathStat.size <= 0 || pathStat.size > LOCK_MAX_BYTES)
-        throw new Error(`${prefix}_owner_record_invalid`);
-    const handle = await fs.open(file, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
-    try {
-        const before = await handle.stat();
-        if (!before.isFile() || before.dev !== pathStat.dev || before.ino !== pathStat.ino
-            || (before.mode & 0o777) !== 0o600 || (expectedUid !== null && before.uid !== expectedUid)) {
-            throw new Error(`${prefix}_identity_mismatch`);
-        }
-        const bytes = await handle.readFile();
-        const after = await handle.stat();
-        const pathAfter = await fs.lstat(file);
-        if (bytes.length <= 0 || bytes.length > LOCK_MAX_BYTES || after.dev !== before.dev
-            || after.ino !== before.ino || after.size !== before.size || pathAfter.dev !== after.dev
-            || pathAfter.ino !== after.ino || pathAfter.isSymbolicLink() || !pathAfter.isFile()
-            || (pathAfter.mode & 0o777) !== 0o600 || (expectedUid !== null && pathAfter.uid !== expectedUid)) {
-            throw new Error(`${prefix}_identity_mismatch`);
-        }
-        let parsed;
-        try {
-            parsed = JSON.parse(bytes.toString('utf8'));
-        }
-        catch {
-            throw new Error(`${prefix}_owner_record_invalid`);
-        }
-        if (!isLockOwner(parsed))
-            throw new Error(`${prefix}_owner_record_invalid`);
-        return { dev: after.dev, ino: after.ino, owner: parsed };
-    }
-    finally {
-        await handle.close();
-    }
-}
-async function unlinkOwnedFile(file, identity, kind) {
-    const current = await inspectOwnerFile(file, kind).catch((error) => {
-        if (error?.code === 'ENOENT'
-            || (kind === 'lock' && isTransientLockInspection(error)))
-            return null;
-        throw error;
-    });
-    if (!current || !sameIdentity(current, identity))
-        return false;
-    try {
-        await fs.unlink(file);
-        return true;
-    }
-    catch (error) {
-        if (error?.code === 'ENOENT')
-            return false;
-        throw error;
-    }
-}
-async function releaseStateLock(lockPath, identity) {
-    if (identity.pid !== process.pid)
-        return false;
-    return unlinkOwnedFile(lockPath, identity, 'lock');
-}
-function sameIdentity(current, expected) {
-    return current.dev === expected.dev && current.ino === expected.ino
-        && current.owner.pid === expected.pid && current.owner.token === expected.token;
-}
-function sameInspectedLock(left, right) {
-    return left.dev === right.dev && left.ino === right.ino
-        && left.owner.pid === right.owner.pid && left.owner.token === right.owner.token;
-}
-function ownerIsDead(owner) {
-    try {
-        process.kill(owner.pid, 0);
-    }
-    catch (error) {
-        const code = error?.code;
-        if (code === 'ESRCH')
-            return true;
-        if (code !== 'EPERM')
-            return false;
-    }
-    if (owner.process_start_seconds === undefined || owner.process_start_seconds === null)
-        return false;
-    const observed = readProcessStartSeconds(owner.pid);
-    return observed !== null && observed !== owner.process_start_seconds;
-}
-function isTransientLockInspection(error) {
-    return error?.code === 'ENOENT'
-        || (error instanceof Error && error.message === 'telegram_state_lock_identity_mismatch');
-}
-function readProcessStartSeconds(pid) {
-    if (!Number.isSafeInteger(pid) || pid <= 0 || process.platform === 'win32')
-        return null;
-    const result = spawnSync('/bin/ps', ['-o', 'lstart=', '-p', String(pid)], {
-        encoding: 'utf8', timeout: 1_000, maxBuffer: 4_096
-    });
-    if (result.status !== 0)
-        return null;
-    const milliseconds = Date.parse(String(result.stdout || '').trim().replace(/\s+/g, ' '));
-    return Number.isFinite(milliseconds) ? Math.floor(milliseconds / 1_000) : null;
-}
-function isLockOwner(value) {
-    if (!isRecord(value))
-        return false;
-    const keys = Object.keys(value);
-    if (keys.some((key) => !['schema', 'pid', 'token', 'process_start_seconds'].includes(key)))
-        return false;
-    return keys.includes('schema') && keys.includes('pid') && keys.includes('token')
-        && value.schema === LOCK_SCHEMA
-        && Number.isSafeInteger(value.pid) && Number(value.pid) > 0 && Number(value.pid) <= 2_147_483_647
-        && typeof value.token === 'string' && LOCK_TOKEN_PATTERN.test(value.token)
-        && (value.process_start_seconds === undefined || value.process_start_seconds === null
-            || (Number.isSafeInteger(value.process_start_seconds) && Number(value.process_start_seconds) > 0));
-}
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}

package/dist/core/telegram/types.js

@@ -1 +0,0 @@
-export const SYSTEM_TELEGRAM_CLOCK = { now: () => Date.now() };