sneakoscope 8.2.0 → 8.3.0

package/dist/core/telegram/confirmation.js

@@ -1,37 +0,0 @@
-import { randomBytes } from 'node:crypto';
-import { SYSTEM_TELEGRAM_CLOCK } from './types.js';
-export class TelegramConfirmationStore {
-    clock;
-    ttlMs;
-    pending = new Map();
-    constructor(options = {}) {
-        this.clock = options.clock ?? SYSTEM_TELEGRAM_CLOCK;
-        this.ttlMs = Math.max(15_000, Math.min(options.ttlMs ?? 2 * 60_000, 10 * 60_000));
-    }
-    issue(command) {
-        this.expire();
-        const nonce = randomBytes(12).toString('base64url');
-        const expiresAt = this.clock.now() + this.ttlMs;
-        this.pending.set(nonce, { ...command, input: structuredClone(command.input), nonce, expiresAt, consumed: false });
-        return { nonce, expires_at: new Date(expiresAt).toISOString() };
-    }
-    consume(nonce, chatId, senderId) {
-        const item = this.pending.get(nonce);
-        if (!item || item.consumed || item.expiresAt <= this.clock.now()) {
-            if (item)
-                this.pending.delete(nonce);
-            return null;
-        }
-        if (item.chatId !== chatId || item.senderId !== senderId)
-            return null;
-        item.consumed = true;
-        this.pending.delete(nonce);
-        return { chatId: item.chatId, senderId: item.senderId, command: item.command, input: structuredClone(item.input) };
-    }
-    expire() {
-        for (const [nonce, item] of this.pending) {
-            if (item.consumed || item.expiresAt <= this.clock.now())
-                this.pending.delete(nonce);
-        }
-    }
-}

package/dist/core/telegram/doctor.js

@@ -1,154 +0,0 @@
-import { redactTelegramError } from './redaction.js';
-import { readTelegramLivenessReceipt, telegramLivenessPath } from './liveness.js';
-export async function probeTelegram(input) {
-    const now = input.now ?? Date.now();
-    if (!input.client || !input.tokenProvider) {
-        return probeTelegramReceipt(input.receiptPath, now);
-    }
-    const receiptProbe = !input.access || !input.poller
-        ? await probeTelegramReceipt(input.receiptPath, now)
-        : null;
-    const blockers = receiptProbe
-        ? receiptProbe.blockers.filter((blocker) => ![
-            'telegram_token_missing',
-            'telegram_getme_not_valid',
-            'telegram_getme_stale'
-        ].includes(blocker))
-        : [];
-    let tokenConfigured = false;
-    try {
-        tokenConfigured = Boolean(String(await input.tokenProvider.loadToken() ?? '').trim());
-    }
-    catch (error) {
-        blockers.push(`telegram_token_load_failed:${redactTelegramError(error)}`);
-    }
-    let identityValid = false;
-    let getMeCheckedAt = null;
-    let getMeLatencyMs = null;
-    if (!tokenConfigured)
-        blockers.push('telegram_token_missing');
-    else {
-        const started = Date.now();
-        try {
-            identityValid = (await input.client.getMe()).is_bot === true;
-            if (!identityValid)
-                blockers.push('telegram_getme_not_bot');
-        }
-        catch (error) {
-            blockers.push(`telegram_getme_failed:${redactTelegramError(error)}`);
-        }
-        finally {
-            getMeLatencyMs = Date.now() - started;
-            getMeCheckedAt = new Date().toISOString();
-        }
-    }
-    let pairedChatCount = receiptProbe?.paired_chat_count ?? 0;
-    if (input.access) {
-        try {
-            pairedChatCount = await input.access.authorizedCount();
-        }
-        catch (error) {
-            blockers.push(`telegram_access_state_failed:${redactTelegramError(error)}`);
-        }
-    }
-    if (pairedChatCount === 0 && !blockers.includes('telegram_private_chat_not_paired')) {
-        blockers.push('telegram_private_chat_not_paired');
-    }
-    let poller = receiptProbe?.poller ?? emptyPoller();
-    if (input.poller) {
-        try {
-            poller = input.poller.snapshot();
-        }
-        catch (error) {
-            blockers.push(`telegram_poller_state_failed:${redactTelegramError(error)}`);
-        }
-    }
-    if (!poller.running && !blockers.includes('telegram_poller_not_running')) {
-        blockers.push('telegram_poller_not_running');
-    }
-    return {
-        schema: 'sks.telegram-doctor-probe.v1',
-        ok: blockers.length === 0,
-        status: !tokenConfigured ? 'not_configured' : blockers.length ? 'degraded' : 'ready',
-        token_configured: tokenConfigured,
-        token_source: tokenConfigured ? (receiptProbe?.token_source ?? 'unknown') : 'none',
-        bot_identity_valid: identityValid,
-        getme_checked_at: getMeCheckedAt,
-        getme_latency_ms: getMeLatencyMs,
-        getme_check_kind: 'live',
-        paired_chat_count: pairedChatCount,
-        audit_healthy: receiptProbe?.audit_healthy ?? true,
-        audit_last_error: receiptProbe?.audit_last_error ?? null,
-        poller,
-        blockers: [...new Set(blockers)],
-        checked_at: new Date().toISOString()
-    };
-}
-async function probeTelegramReceipt(receiptPath, now) {
-    const liveness = await readTelegramLivenessReceipt(receiptPath ?? telegramLivenessPath(), now);
-    if (!liveness.ok) {
-        return {
-            schema: 'sks.telegram-doctor-probe.v1', ok: false, status: 'not_configured',
-            token_configured: false, bot_identity_valid: false, paired_chat_count: 0,
-            token_source: 'none',
-            audit_healthy: false, audit_last_error: null,
-            getme_checked_at: null, getme_latency_ms: null,
-            getme_check_kind: 'receipt',
-            poller: emptyPoller(), blockers: [liveness.blocker], checked_at: new Date(now).toISOString()
-        };
-    }
-    const receipt = liveness.receipt;
-    const blockers = [];
-    if (!receipt.token_configured)
-        blockers.push('telegram_token_missing');
-    if (receipt.token_configured && !receipt.bot_identity_valid)
-        blockers.push('telegram_getme_not_valid');
-    const getMeAge = receipt.getme_checked_at ? now - Date.parse(receipt.getme_checked_at) : Number.POSITIVE_INFINITY;
-    if (receipt.bot_identity_valid && getMeAge > 10 * 60_000)
-        blockers.push('telegram_getme_stale');
-    if (receipt.paired_chat_count === 0)
-        blockers.push('telegram_private_chat_not_paired');
-    if (receipt.audit_healthy === false)
-        blockers.push('telegram_audit_unavailable');
-    if (!receipt.running || !receipt.poller.running)
-        blockers.push('telegram_poller_not_running');
-    if (liveness.stale)
-        blockers.push('telegram_liveness_stale');
-    if (receipt.poller.consecutive_failures > 0)
-        blockers.push('telegram_poller_degraded');
-    return {
-        schema: 'sks.telegram-doctor-probe.v1',
-        ok: blockers.length === 0,
-        status: !receipt.token_configured ? 'not_configured' : blockers.length ? 'degraded' : 'ready',
-        token_configured: receipt.token_configured,
-        token_source: receipt.token_source ?? (receipt.token_configured ? 'unknown' : 'none'),
-        bot_identity_valid: receipt.bot_identity_valid,
-        getme_checked_at: receipt.getme_checked_at ?? null,
-        getme_latency_ms: receipt.getme_latency_ms ?? null,
-        getme_check_kind: 'receipt',
-        paired_chat_count: receipt.paired_chat_count,
-        audit_healthy: receipt.audit_healthy !== false,
-        audit_last_error: receipt.audit_last_error ?? null,
-        poller: receipt.poller,
-        blockers,
-        checked_at: new Date(now).toISOString()
-    };
-}
-function emptyPoller() {
-    return {
-        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
-    };
-}
-export function telegramSelfHealAction(probe) {
-    if (!probe.audit_healthy || probe.blockers.includes('telegram_audit_unavailable'))
-        return 'operator_repair_audit';
-    if (!probe.token_configured || !probe.bot_identity_valid || probe.blockers.includes('telegram_getme_stale'))
-        return 'revalidate_token';
-    if (/409|webhook/i.test(probe.poller.last_error ?? ''))
-        return 'operator_remove_webhook';
-    if (probe.blockers.includes('telegram_liveness_stale') || !probe.poller.running || probe.poller.consecutive_failures > 0)
-        return 'restart_poll';
-    return 'none';
-}

package/dist/core/telegram/index.js

@@ -1,9 +0,0 @@
-export * from './access.js';
-export * from './client.js';
-export * from './confirmation.js';
-export * from './doctor.js';
-export * from './liveness.js';
-export * from './keychain.js';
-export * from './poller.js';
-export * from './redaction.js';
-export * from './types.js';

package/dist/core/telegram/keychain.js

@@ -1,317 +0,0 @@
-import fs from 'node:fs/promises';
-import { constants as fsConstants } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { randomInt, randomUUID } from 'node:crypto';
-import { assertTestHomeWriteAllowed } from '../fsx.js';
-import { PrivateCredentialFileError, readPrivateCredentialFile, writePrivateTextAtomic } from '../security/private-credential-file.js';
-import { withTelegramStateLock } from './state-lock.js';
-export const TELEGRAM_TOKEN_ENV_NAMES = ['TELEGRAM_BOT_TOKEN', 'SKS_TELEGRAM_BOT_TOKEN'];
-export const TELEGRAM_STATE_SCHEMA = 'sks.telegram-state.v1';
-export const TELEGRAM_PAIRING_SCHEMA = 'sks.telegram-pairing.v1';
-export const TELEGRAM_STATE_MAX_BYTES = 1024 * 1024;
-const TELEGRAM_TOKEN_PATTERN = /^\d{5,20}:[A-Za-z0-9_-]{20,128}$/;
-const TELEGRAM_TOKEN_MAX_BYTES = 1024;
-export function telegramPrivatePaths(env = process.env) {
-    const sksHome = path.resolve(env.SKS_HOME || path.join(env.HOME || os.homedir(), '.sneakoscope'));
-    const secretDir = path.join(sksHome, 'secrets');
-    const stateDir = path.join(sksHome, 'state');
-    return {
-        sksHome,
-        secretDir,
-        tokenPath: path.join(secretDir, 'telegram-bot-token'),
-        stateDir,
-        statePath: path.join(stateDir, 'telegram.json'),
-        stateLockPath: path.join(stateDir, '.telegram.lock')
-    };
-}
-export function isValidTelegramBotToken(value) {
-    return TELEGRAM_TOKEN_PATTERN.test(String(value ?? '').trim());
-}
-export async function resolveTelegramBotToken(input = {}) {
-    const env = input.env || process.env;
-    for (const name of TELEGRAM_TOKEN_ENV_NAMES) {
-        const token = String(env[name] || '').trim();
-        if (token) {
-            if (!isValidTelegramBotToken(token))
-                throw new Error('telegram_token_invalid');
-            return { token, source: 'env', env_var: name };
-        }
-    }
-    const token = await readStoredTelegramToken(input.paths || telegramPrivatePaths(env));
-    return token ? { token, source: 'user_secret_file' } : { token: null, source: null };
-}
-export async function readStoredTelegramToken(paths = telegramPrivatePaths()) {
-    if (!await validateExistingPrivateDirectories(paths, 'token'))
-        return null;
-    try {
-        const token = (await readPrivateCredentialFile(paths.sksHome, paths.tokenPath, 'telegram_bot_token', { maxBytes: TELEGRAM_TOKEN_MAX_BYTES })).bytes.toString('utf8').trim();
-        if (!token)
-            return null;
-        if (!isValidTelegramBotToken(token))
-            throw new Error('telegram_token_invalid');
-        return token;
-    }
-    catch (error) {
-        if (error instanceof PrivateCredentialFileError && error.code === 'missing')
-            return null;
-        throw error;
-    }
-}
-export async function storeTelegramToken(tokenInput, options = {}) {
-    const token = String(tokenInput ?? '').trim();
-    if (!isValidTelegramBotToken(token))
-        throw new Error('telegram_token_invalid');
-    const paths = resolvePrivatePaths(options);
-    await ensureTelegramPrivateDirectories(paths, 'token');
-    await writePrivateTextAtomic(paths.sksHome, paths.tokenPath, `${token}\n`, 'telegram_bot_token');
-}
-export async function preflightTelegramTokenStorage(tokenInput, options = {}) {
-    const token = String(tokenInput ?? '').trim();
-    if (!isValidTelegramBotToken(token))
-        throw new Error('telegram_token_invalid');
-    const paths = resolvePrivatePaths(options);
-    await ensureTelegramPrivateDirectories(paths, 'token');
-    try {
-        await readPrivateCredentialFile(paths.sksHome, paths.tokenPath, 'telegram_bot_token', { maxBytes: TELEGRAM_TOKEN_MAX_BYTES });
-    }
-    catch (error) {
-        if (!(error instanceof PrivateCredentialFileError && error.code === 'missing'))
-            throw error;
-    }
-    const probePath = path.join(paths.secretDir, `.telegram-token-preflight.${randomUUID()}`);
-    assertTestHomeWriteAllowed(probePath);
-    let handle = null;
-    let identity = null;
-    try {
-        handle = await fs.open(probePath, 'wx', 0o600);
-        const stat = await handle.stat();
-        if (!stat.isFile() || (stat.mode & 0o777) !== 0o600)
-            throw new Error('telegram_token_preflight_unsafe_file');
-        const expectedUid = typeof process.getuid === 'function' ? process.getuid() : null;
-        if (expectedUid !== null && stat.uid !== expectedUid)
-            throw new Error('telegram_token_preflight_owner_mismatch');
-        identity = { dev: stat.dev, ino: stat.ino };
-        await handle.writeFile(`${'x'.repeat(Buffer.byteLength(token, 'utf8'))}\n`, 'utf8');
-        await handle.sync();
-    }
-    finally {
-        await handle?.close().catch(() => undefined);
-        const current = await fs.lstat(probePath).catch(() => null);
-        if (identity && current?.isFile() && !current.isSymbolicLink()
-            && current.dev === identity.dev && current.ino === identity.ino) {
-            await fs.unlink(probePath);
-        }
-    }
-}
-export async function bindTelegramBotIdentity(botId, options = {}) {
-    if (!Number.isSafeInteger(botId) || botId <= 0)
-        throw new Error('telegram_bot_id_invalid');
-    let result = null;
-    await updateTelegramState((state) => {
-        const previousBotId = state.bot_id;
-        const rotated = previousBotId !== botId;
-        const legacyOrPendingChat = state.chats.length > 1 || state.chats.some((chat) => chat.active === false);
-        const stateReset = rotated || legacyOrPendingChat;
-        result = {
-            bot_id: botId,
-            previous_bot_id: previousBotId,
-            rotated,
-            state_reset: stateReset
-        };
-        return {
-            ...state,
-            bot_id: botId,
-            ...(stateReset ? {
-                poll_offset: 0,
-                pairing: null,
-                chats: [],
-                confirmations: []
-            } : {})
-        };
-    }, resolvePrivatePaths(options));
-    if (!result)
-        throw new Error('telegram_bot_binding_failed');
-    return result;
-}
-export function emptyTelegramState() {
-    return {
-        schema: TELEGRAM_STATE_SCHEMA,
-        bot_id: null,
-        poll_offset: 0,
-        pairing: null,
-        chats: [],
-        confirmations: []
-    };
-}
-export async function readTelegramState(paths = telegramPrivatePaths()) {
-    if (!await validateExistingPrivateDirectories(paths, 'state'))
-        return emptyTelegramState();
-    let bytes;
-    try {
-        bytes = (await readPrivateCredentialFile(paths.sksHome, paths.statePath, 'telegram_state', { maxBytes: TELEGRAM_STATE_MAX_BYTES })).bytes;
-    }
-    catch (error) {
-        if (error instanceof PrivateCredentialFileError && error.code === 'missing')
-            return emptyTelegramState();
-        throw error;
-    }
-    if (bytes.length > TELEGRAM_STATE_MAX_BYTES)
-        throw new Error('telegram_state_too_large');
-    let parsed;
-    try {
-        parsed = JSON.parse(bytes.toString('utf8'));
-    }
-    catch {
-        throw new Error('telegram_state_invalid');
-    }
-    if (!isTelegramState(parsed))
-        throw new Error('telegram_state_invalid');
-    return normalizeTelegramState(parsed);
-}
-export async function writeTelegramState(state, paths = telegramPrivatePaths()) {
-    if (!isTelegramState(state))
-        throw new Error('telegram_state_invalid');
-    const normalized = normalizeTelegramState(state);
-    await ensureTelegramPrivateDirectories(paths, 'state');
-    const serialized = `${JSON.stringify(normalized, null, 2)}\n`;
-    if (Buffer.byteLength(serialized, 'utf8') > TELEGRAM_STATE_MAX_BYTES) {
-        throw new Error('telegram_state_too_large');
-    }
-    await writePrivateTextAtomic(paths.sksHome, paths.statePath, serialized, 'telegram_state');
-}
-export async function updateTelegramState(update, paths = telegramPrivatePaths()) {
-    await ensureTelegramPrivateDirectories(paths, 'state');
-    return withTelegramStateLock(paths, async () => {
-        const next = await update(await readTelegramState(paths));
-        await writeTelegramState(next, paths);
-        return next;
-    });
-}
-export async function issueTelegramPairingCode(options = {}) {
-    const now = options.now ?? Date.now();
-    const ttlMs = Math.max(30_000, Math.min(options.ttlMs ?? 5 * 60_000, 15 * 60_000));
-    const result = {
-        code: `${randomInt(100_000, 1_000_000)}-${randomUUID().slice(0, 4).toUpperCase()}`,
-        expires_at: new Date(now + ttlMs).toISOString()
-    };
-    await updateTelegramState((state) => ({
-        ...state,
-        ...(state.chats.length > 1 ? {
-            poll_offset: 0,
-            chats: [],
-            confirmations: []
-        } : {}),
-        pairing: {
-            schema: TELEGRAM_PAIRING_SCHEMA,
-            ...result,
-            used: false
-        }
-    }), resolvePrivatePaths(options));
-    return result;
-}
-async function ensureTelegramPrivateDirectories(paths, target) {
-    await ensurePrivateDirectory(paths.sksHome, 'telegram_sks_home', false);
-    await ensurePrivateDirectory(target === 'token' ? paths.secretDir : paths.stateDir, `telegram_${target}_directory`);
-}
-async function validateExistingPrivateDirectories(paths, target) {
-    if (!await pathExists(paths.sksHome))
-        return false;
-    await inspectPrivateDirectory(paths.sksHome, 'telegram_sks_home', false);
-    const child = target === 'token' ? paths.secretDir : paths.stateDir;
-    if (!await pathExists(child))
-        return false;
-    await inspectPrivateDirectory(child, `telegram_${target}_directory`);
-    return true;
-}
-async function ensurePrivateDirectory(directory, label, requireMode0700 = true) {
-    assertTestHomeWriteAllowed(directory);
-    try {
-        await fs.mkdir(directory, { mode: 0o700 });
-    }
-    catch (error) {
-        if (error?.code !== 'EEXIST')
-            throw error;
-    }
-    await inspectPrivateDirectory(directory, label, requireMode0700);
-}
-async function inspectPrivateDirectory(directory, label, requireMode0700 = true) {
-    const stat = await fs.lstat(directory);
-    if (stat.isSymbolicLink() || !stat.isDirectory())
-        throw new Error(`${label}_unsafe_type`);
-    if (requireMode0700 && (stat.mode & 0o777) !== 0o700)
-        throw new Error(`${label}_mode_not_0700`);
-    if (!requireMode0700 && (stat.mode & 0o022) !== 0)
-        throw new Error(`${label}_group_or_other_writable`);
-    const expectedUid = typeof process.getuid === 'function' ? process.getuid() : null;
-    if (expectedUid !== null && stat.uid !== expectedUid)
-        throw new Error(`${label}_owner_mismatch`);
-    return stat;
-}
-async function pathExists(file) {
-    try {
-        await fs.lstat(file);
-        return true;
-    }
-    catch (error) {
-        if (error?.code === 'ENOENT')
-            return false;
-        throw error;
-    }
-}
-function resolvePrivatePaths(options) {
-    if (options.paths)
-        return options.paths;
-    if (!options.home)
-        return telegramPrivatePaths(options.env || process.env);
-    return telegramPrivatePaths({ ...(options.env || process.env), SKS_HOME: undefined, HOME: options.home });
-}
-function isTelegramState(value) {
-    if (!isRecord(value)
-        || value.schema !== TELEGRAM_STATE_SCHEMA
-        || !Array.isArray(value.chats)
-        || !Array.isArray(value.confirmations))
-        return false;
-    if (value.bot_id !== undefined && value.bot_id !== null
-        && (!Number.isSafeInteger(value.bot_id) || Number(value.bot_id) <= 0))
-        return false;
-    if (value.poll_offset !== undefined
-        && (!Number.isSafeInteger(value.poll_offset) || Number(value.poll_offset) < 0))
-        return false;
-    if (value.pairing !== null && !isPairing(value.pairing))
-        return false;
-    return value.chats.every((chat) => isRecord(chat)
-        && Number.isSafeInteger(chat.chat_id)
-        && Number(chat.chat_id) > 0
-        && Number.isSafeInteger(chat.sender_id)
-        && Number(chat.sender_id) > 0
-        && typeof chat.paired_at === 'string'
-        && (chat.active === undefined || typeof chat.active === 'boolean'))
-        && value.confirmations.every((confirmation) => isRecord(confirmation)
-            && typeof confirmation.nonce === 'string'
-            && Number.isSafeInteger(confirmation.chat_id)
-            && Number(confirmation.chat_id) > 0
-            && Number.isSafeInteger(confirmation.sender_id)
-            && Number(confirmation.sender_id) > 0
-            && typeof confirmation.command === 'string'
-            && typeof confirmation.input_json === 'string'
-            && typeof confirmation.expires_at === 'string');
-}
-function normalizeTelegramState(value) {
-    return {
-        ...value,
-        bot_id: value.bot_id ?? null,
-        poll_offset: value.poll_offset ?? 0,
-        chats: value.chats.map((chat) => ({ ...chat, active: chat.active ?? true }))
-    };
-}
-function isPairing(value) {
-    return isRecord(value)
-        && value.schema === TELEGRAM_PAIRING_SCHEMA
-        && typeof value.code === 'string'
-        && typeof value.expires_at === 'string'
-        && typeof value.used === 'boolean';
-}
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}

package/dist/core/telegram/liveness.js

@@ -1,124 +0,0 @@
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { randomUUID } from 'node:crypto';
-const MAX_RECEIPT_BYTES = 64 * 1024;
-export function telegramLivenessPath(home = process.env.HOME || os.homedir()) {
-    return path.join(path.resolve(home), '.codex', 'sks-menubar', 'telegram-liveness.json');
-}
-export function createTelegramLivenessReceipt(input) {
-    if (!optionalPositiveSafeInteger(input.botId))
-        throw new Error('telegram_liveness_bot_id_invalid');
-    return {
-        schema: 'sks.telegram-liveness.v1',
-        generation: input.generation,
-        pid: input.pid ?? process.pid,
-        running: input.running,
-        token_configured: input.tokenConfigured,
-        token_source: input.tokenSource ?? (input.tokenConfigured ? 'unknown' : 'none'),
-        bot_id: input.botId ?? null,
-        bot_identity_valid: input.botIdentityValid,
-        getme_checked_at: input.getMeCheckedAt ?? (input.botIdentityValid ? (input.heartbeatAt ?? new Date().toISOString()) : null),
-        getme_latency_ms: input.getMeLatencyMs ?? (input.botIdentityValid ? 0 : null),
-        paired_chat_count: Math.max(0, Math.floor(input.pairedChatCount)),
-        started_at: input.startedAt,
-        heartbeat_at: input.heartbeatAt ?? new Date().toISOString(),
-        stale_after_seconds: Math.max(15, Math.min(input.staleAfterSeconds ?? 120, 600)),
-        audit_healthy: input.auditHealthy ?? true,
-        audit_last_error: input.auditLastError ?? null,
-        poller: { ...input.poller }
-    };
-}
-export async function writeTelegramLivenessReceipt(file, receipt) {
-    const target = path.resolve(file);
-    const directory = path.dirname(target);
-    await fs.mkdir(directory, { recursive: true, mode: 0o700 });
-    const temporary = path.join(directory, `.${path.basename(target)}.${randomUUID()}.tmp`);
-    try {
-        await fs.writeFile(temporary, `${JSON.stringify(receipt, null, 2)}\n`, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
-        await fs.rename(temporary, target);
-        await fs.chmod(target, 0o600);
-    }
-    finally {
-        await fs.rm(temporary, { force: true }).catch(() => undefined);
-    }
-}
-export async function readTelegramLivenessReceipt(file = telegramLivenessPath(), now = Date.now()) {
-    const target = path.resolve(file);
-    const stat = await fs.lstat(target).catch(() => null);
-    if (!stat)
-        return { ok: false, receipt: null, blocker: 'telegram_liveness_missing' };
-    if (!stat.isFile() || stat.isSymbolicLink())
-        return { ok: false, receipt: null, blocker: 'telegram_liveness_unsafe_type' };
-    if (stat.size <= 0 || stat.size > MAX_RECEIPT_BYTES)
-        return { ok: false, receipt: null, blocker: 'telegram_liveness_invalid_size' };
-    if (process.platform !== 'win32' && (stat.mode & 0o077) !== 0) {
-        return { ok: false, receipt: null, blocker: 'telegram_liveness_insecure_mode' };
-    }
-    if (typeof process.getuid === 'function' && stat.uid !== process.getuid()) {
-        return { ok: false, receipt: null, blocker: 'telegram_liveness_wrong_owner' };
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(await fs.readFile(target, 'utf8'));
-    }
-    catch {
-        return { ok: false, receipt: null, blocker: 'telegram_liveness_invalid_json' };
-    }
-    if (!isTelegramLivenessReceipt(parsed)) {
-        return { ok: false, receipt: null, blocker: 'telegram_liveness_invalid_schema' };
-    }
-    const heartbeat = Date.parse(parsed.heartbeat_at);
-    const ageMs = Number.isFinite(heartbeat) ? Math.max(0, now - heartbeat) : Number.POSITIVE_INFINITY;
-    return {
-        ok: true,
-        receipt: parsed,
-        stale: ageMs > parsed.stale_after_seconds * 1_000,
-        age_ms: ageMs
-    };
-}
-function isTelegramLivenessReceipt(value) {
-    if (!value || typeof value !== 'object')
-        return false;
-    const row = value;
-    return row.schema === 'sks.telegram-liveness.v1'
-        && typeof row.generation === 'string' && row.generation.length >= 8 && row.generation.length <= 128
-        && Number.isSafeInteger(row.pid) && Number(row.pid) > 0
-        && typeof row.running === 'boolean'
-        && typeof row.token_configured === 'boolean'
-        && (row.token_source === undefined || ['env', 'user_secret_file', 'none', 'unknown'].includes(String(row.token_source)))
-        && optionalPositiveSafeInteger(row.bot_id)
-        && typeof row.bot_identity_valid === 'boolean'
-        && optionalNullableIso(row.getme_checked_at)
-        && (row.getme_latency_ms === undefined || row.getme_latency_ms === null
-            || (Number.isFinite(row.getme_latency_ms) && Number(row.getme_latency_ms) >= 0))
-        && Number.isSafeInteger(row.paired_chat_count) && Number(row.paired_chat_count) >= 0
-        && typeof row.started_at === 'string' && Number.isFinite(Date.parse(row.started_at))
-        && typeof row.heartbeat_at === 'string' && Number.isFinite(Date.parse(row.heartbeat_at))
-        && Number.isFinite(row.stale_after_seconds) && Number(row.stale_after_seconds) >= 15
-        && (row.audit_healthy === undefined || typeof row.audit_healthy === 'boolean')
-        && (row.audit_last_error === undefined || row.audit_last_error === null || typeof row.audit_last_error === 'string')
-        && isPollSnapshot(row.poller);
-}
-function optionalPositiveSafeInteger(value) {
-    return value === undefined || value === null || (Number.isSafeInteger(value) && Number(value) > 0);
-}
-function isPollSnapshot(value) {
-    if (!value || typeof value !== 'object')
-        return false;
-    const row = value;
-    return row.schema === 'sks.telegram-poller-state.v1'
-        && typeof row.running === 'boolean'
-        && Number.isSafeInteger(row.offset) && Number(row.offset) >= 0
-        && Number.isSafeInteger(row.consecutive_failures) && Number(row.consecutive_failures) >= 0
-        && optionalNullableIso(row.last_poll_at)
-        && optionalNullableIso(row.last_success_at)
-        && optionalNullableIso(row.last_update_at)
-        && (row.last_error === undefined || row.last_error === null || typeof row.last_error === 'string');
-}
-function nullableIso(value) {
-    return value === null || (typeof value === 'string' && Number.isFinite(Date.parse(value)));
-}
-function optionalNullableIso(value) {
-    return value === undefined || nullableIso(value);
-}