sneakoscope 8.2.0 → 8.3.0

package/dist/core/commands/telegram-command.js

@@ -1,447 +0,0 @@
-import { commandContract, outputCapFor, timeoutFor } from '../safety/command-contract/contracts.js';
-import { validateJsonSchema } from '../safety/command-contract/json-schema.js';
-import { probeTelegram, telegramSelfHealAction } from '../telegram/doctor.js';
-import { readTelegramLivenessReceipt, telegramLivenessPath } from '../telegram/liveness.js';
-import { TELEGRAM_TOKEN_ENV_NAMES, bindTelegramBotIdentity, issueTelegramPairingCode, preflightTelegramTokenStorage, storeTelegramToken } from '../telegram/keychain.js';
-import { spawn } from 'node:child_process';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { TelegramApiError, TelegramClient } from '../telegram/client.js';
-import { redactTelegramError } from '../telegram/redaction.js';
-import { projectRoot } from '../fsx.js';
-import { projectRootRealpath } from '../session/project-namespace.js';
-export const TELEGRAM_COMMAND_WHITELIST = new Set([
-    'gates', 'paths', 'pipeline', 'proof', 'search', 'stats', 'status',
-    'stop-gate', 'trust', 'update-check', 'validate-artifacts'
-]);
-export const TELEGRAM_CONFIRMATION_REQUIRED = new Set([
-    'gates', 'stop-gate', 'validate-artifacts'
-]);
-export function createTelegramCommandDispatcher(adapter, lookup = commandContract) {
-    const resolve = (request) => {
-        if (!TELEGRAM_COMMAND_WHITELIST.has(request.name))
-            return { error: 'telegram_command_not_whitelisted' };
-        const contract = lookup(request.name);
-        if (!contract || !contract.remote_allowed || contract.risk === 'R3')
-            return { error: 'telegram_command_not_remote_allowed' };
-        const validation = validateJsonSchema(request.input, contract.input_schema);
-        if (!validation.ok)
-            return { error: `telegram_command_input_invalid:${validation.issues[0]?.code ?? 'schema'}` };
-        return { contract, argv: contract.argv_builder(validation.value) };
-    };
-    return {
-        prepare(request) {
-            const resolved = resolve(request);
-            if ('error' in resolved)
-                return { ok: false, error: resolved.error };
-            if (requiresConfirmation(resolved.contract))
-                return { ok: true, confirmation_required: true };
-            return {
-                ok: true,
-                confirmation_required: false,
-                execute: () => adapter.executeArgv(resolved.argv, resolved.contract)
-            };
-        },
-        async executeConfirmed(request) {
-            const resolved = resolve(request);
-            if ('error' in resolved)
-                throw new Error(resolved.error);
-            if (!requiresConfirmation(resolved.contract))
-                throw new Error('telegram_confirmation_not_required');
-            return adapter.executeArgv(resolved.argv, resolved.contract);
-        }
-    };
-}
-function requiresConfirmation(contract) {
-    return TELEGRAM_CONFIRMATION_REQUIRED.has(contract.name) || !contract.read_only || contract.risk !== 'R0';
-}
-export function usage() {
-    return [
-        'Usage: sks telegram status|doctor|pair|setup [--json]',
-        '',
-        '  status               Read the secret-free resident poller liveness receipt.',
-        '  doctor               Evaluate getMe, pairing, poller, and liveness evidence.',
-        '  pair                 Issue a short-lived code for the intended private Telegram chat.',
-        '  setup --token-stdin [--remove-webhook]',
-        '                       Verify and store the token for any @BotFather bot you own; an existing webhook requires explicit removal consent.',
-        '  prepare --stdin-json  Validate an authorized native request through the typed contract.',
-        '  execute --stdin-json  Execute a prepared request; destructive requests also need --confirmed.',
-        '',
-        'After pairing, send /sks status {}. Confirm prompted actions with /confirm <nonce>.',
-        'The bot token is never accepted in argv, printed, or written to a config file.'
-    ].join('\n');
-}
-export async function telegramCommand(args = [], dependencies = {}) {
-    if (args.some((value) => ['help', '--help', '-h'].includes(value.toLowerCase()))) {
-        console.log(usage());
-        return { schema: 'sks.telegram-command.v1', ok: true, action: 'help' };
-    }
-    const action = args[0] && !args[0].startsWith('-') ? args[0].toLowerCase() : 'status';
-    const json = args.includes('--json');
-    const receiptPath = dependencies.receiptPath ?? telegramLivenessPath();
-    try {
-        if (action === 'status') {
-            const state = await readTelegramLivenessReceipt(receiptPath);
-            const result = state.ok
-                ? { schema: 'sks.telegram-status.v1', ok: !state.stale && state.receipt.running, stale: state.stale, age_ms: state.age_ms, receipt: state.receipt }
-                : { schema: 'sks.telegram-status.v1', ok: false, blocker: state.blocker };
-            if (!result.ok)
-                process.exitCode = 1;
-            return emit(result, json);
-        }
-        if (action === 'doctor') {
-            const probe = await probeTelegram({ receiptPath });
-            const result = { ...probe, self_heal_action: telegramSelfHealAction(probe) };
-            if (!result.ok)
-                process.exitCode = 1;
-            return emit(result, json);
-        }
-        if (action === 'pair') {
-            const issued = await (dependencies.issuePairingCode ?? issueTelegramPairingCode)();
-            return emit({
-                schema: 'sks.telegram-pair-command.v1', ok: true,
-                code: issued.code, expires_at: issued.expires_at,
-                instruction: `Send /start ${issued.code} to the configured bot from the intended private chat. Then send /sks status {}.`,
-                post_pair_command: '/sks status {}',
-                confirmation_grammar: '/confirm <nonce>'
-            }, json);
-        }
-        if (action === 'setup') {
-            if (!args.includes('--token-stdin'))
-                return telegramSetupFailure('telegram_token_stdin_required', json);
-            if (args.includes('--drop-pending-updates'))
-                return telegramSetupFailure('telegram_drop_pending_updates_unsupported', json);
-            const environment = dependencies.environment ?? process.env;
-            const envOverrideActive = args.includes('--operator-env-override-active')
-                || TELEGRAM_TOKEN_ENV_NAMES.some((name) => String(environment[name] ?? '').trim().length > 0);
-            if (envOverrideActive)
-                return telegramSetupEnvOverrideBlocked(json);
-            const token = await (dependencies.readTokenStdin ?? readBoundedTokenStdin)();
-            let identity;
-            try {
-                identity = await (dependencies.verifyToken ?? verifyTelegramToken)(token);
-            }
-            catch (error) {
-                return telegramSetupFailure(telegramIdentityFailure(error), json, 'getme');
-            }
-            const removeWebhook = args.includes('--remove-webhook');
-            let webhook;
-            try {
-                webhook = await (dependencies.inspectWebhook ?? inspectTelegramWebhook)(token);
-            }
-            catch (error) {
-                throw new Error(`telegram_webhook_inspection_failed:${redactTelegramError(error, token)}`);
-            }
-            const webhookConfigured = webhook.url.trim().length > 0;
-            if (webhookConfigured && !removeWebhook) {
-                throw new Error('telegram_webhook_configured_remove_consent_required');
-            }
-            await (dependencies.preflightTokenStorage ?? preflightTelegramTokenStorage)(token);
-            let webhookRemoved = false;
-            if (webhookConfigured) {
-                try {
-                    await (dependencies.removeWebhook ?? removeTelegramWebhook)(token);
-                    webhookRemoved = true;
-                }
-                catch (error) {
-                    throw new Error(`telegram_webhook_remove_failed:${redactTelegramError(error, token)}`);
-                }
-            }
-            let binding = null;
-            if (identity) {
-                try {
-                    binding = await (dependencies.bindBotIdentity ?? bindTelegramBotIdentity)(identity.id);
-                }
-                catch (error) {
-                    if (webhookRemoved) {
-                        return telegramSetupPartialFailure({
-                            error: 'telegram_bot_state_bind_failed_after_webhook_removed',
-                            detail: redactTelegramError(error, token),
-                            webhookRemoved,
-                            botId: identity.id
-                        }, json);
-                    }
-                    throw error;
-                }
-            }
-            try {
-                await (dependencies.storeToken ?? storeTelegramToken)(token);
-            }
-            catch (error) {
-                if (webhookRemoved || binding) {
-                    return telegramSetupPartialFailure({
-                        error: webhookRemoved
-                            ? 'telegram_token_store_failed_after_webhook_removed'
-                            : 'telegram_token_store_failed_after_bot_state_binding',
-                        detail: redactTelegramError(error, token),
-                        webhookRemoved,
-                        botId: identity?.id ?? null,
-                        binding
-                    }, json);
-                }
-                throw error;
-            }
-            return emit({
-                schema: 'sks.telegram-setup-command.v1', ok: true,
-                getme_verified: true, token_stored: true, storage: 'user_secret_file',
-                token_source: 'user_secret_file',
-                webhook_configured_before: webhookConfigured,
-                webhook_removed: webhookRemoved, pending_updates_dropped: false,
-                bot_id: identity?.id ?? null,
-                bot_username: publicBotUsername(identity?.username),
-                bot_rotated: binding?.rotated ?? false,
-                bot_state_reset: binding?.state_reset ?? false,
-                restart_required: true
-            }, json);
-        }
-        if (action === 'prepare' || action === 'execute') {
-            if (!args.includes('--stdin-json'))
-                return fail('telegram_command_stdin_json_required', json);
-            const commandRoot = await resolveTelegramCommandRoot(args, dependencies.resolveProjectRoot);
-            const request = await (dependencies.readCommandStdin ?? readBoundedCommandStdin)();
-            const executionAdapter = dependencies.executionAdapter ?? { executeArgv: executeTypedArgv };
-            const dispatcher = createTelegramCommandDispatcher({
-                executeArgv: (argv, contract) => executionAdapter.executeArgv(argv, contract, commandRoot)
-            });
-            const prepared = dispatcher.prepare(request);
-            if (action === 'prepare') {
-                return emit(prepared.ok
-                    ? { schema: 'sks.telegram-command-preparation.v1', ok: true, allowed: true, confirmation_required: prepared.confirmation_required, public_error: null }
-                    : { schema: 'sks.telegram-command-preparation.v1', ok: false, allowed: false, confirmation_required: false, public_error: prepared.error }, json);
-            }
-            if (!prepared.ok)
-                return fail(prepared.error, json);
-            if (prepared.confirmation_required && !args.includes('--confirmed'))
-                return fail('telegram_confirmation_required', json);
-            const output = prepared.confirmation_required
-                ? await dispatcher.executeConfirmed(request)
-                : await prepared.execute();
-            return emit({ schema: 'sks.telegram-command-execution.v1', ok: true, output }, json);
-        }
-        return fail('telegram_unknown_action', json, ['status', 'doctor', 'pair', 'setup', 'prepare', 'execute']);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return action === 'setup'
-            ? telegramSetupFailure(redactTelegramError(error), json)
-            : fail(message, json);
-    }
-}
-async function verifyTelegramToken(token) {
-    const client = new TelegramClient({ tokenProvider: { loadToken: async () => token } });
-    const identity = await client.getMe();
-    if (!identity.is_bot)
-        throw new Error('telegram_getme_not_bot');
-    if (!Number.isSafeInteger(identity.id) || identity.id <= 0)
-        throw new Error('telegram_getme_bot_id_invalid');
-    return identity;
-}
-async function inspectTelegramWebhook(token) {
-    const client = new TelegramClient({ tokenProvider: { loadToken: async () => token } });
-    return client.getWebhookInfo();
-}
-async function removeTelegramWebhook(token) {
-    const client = new TelegramClient({ tokenProvider: { loadToken: async () => token } });
-    await client.deleteWebhook();
-}
-async function readBoundedCommandStdin() {
-    if (process.stdin.isTTY)
-        throw new Error('telegram_command_stdin_json_required');
-    process.stdin.setEncoding('utf8');
-    let value = '';
-    for await (const chunk of process.stdin) {
-        value += String(chunk);
-        if (Buffer.byteLength(value, 'utf8') > 32 * 1024)
-            throw new Error('telegram_command_stdin_json_too_large');
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(value);
-    }
-    catch {
-        throw new Error('telegram_command_stdin_json_invalid');
-    }
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
-        throw new Error('telegram_command_stdin_json_invalid');
-    const row = parsed;
-    if (typeof row.name !== 'string' || !row.input || typeof row.input !== 'object' || Array.isArray(row.input)) {
-        throw new Error('telegram_command_stdin_json_invalid');
-    }
-    return { name: row.name, input: row.input };
-}
-async function executeTypedArgv(argv, contract, cwd = process.cwd()) {
-    const entrypoint = process.argv[1];
-    if (!entrypoint)
-        throw new Error('telegram_cli_entrypoint_unavailable');
-    const timeoutMs = timeoutFor(contract.latency);
-    const outputLimit = outputCapFor(contract.latency);
-    const childEnv = { ...process.env };
-    for (const name of TELEGRAM_TOKEN_ENV_NAMES)
-        delete childEnv[name];
-    return new Promise((resolve, reject) => {
-        const child = spawn(process.execPath, [entrypoint, ...argv], {
-            cwd, env: childEnv, stdio: ['ignore', 'pipe', 'pipe'], shell: false
-        });
-        let output = Buffer.alloc(0);
-        let settled = false;
-        const timer = setTimeout(() => finish(new Error('telegram_command_timeout')), timeoutMs);
-        const append = (chunk) => {
-            if (settled)
-                return;
-            output = Buffer.concat([output, chunk]);
-            if (output.length > outputLimit)
-                finish(new Error('telegram_command_output_limit'));
-        };
-        const finish = (error, code) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            if (child.exitCode === null)
-                child.kill('SIGKILL');
-            if (error)
-                return reject(error);
-            const text = output.toString('utf8').trim();
-            if (code !== 0)
-                return reject(new Error(`telegram_command_failed:exit_${code ?? 'signal'}`));
-            try {
-                resolve(JSON.parse(text));
-            }
-            catch {
-                resolve(text);
-            }
-        };
-        child.stdout.on('data', append);
-        child.stderr.on('data', append);
-        child.once('error', (error) => finish(new Error(`telegram_command_spawn_failed:${error.message}`)));
-        child.once('close', (code) => finish(undefined, code));
-    });
-}
-async function resolveTelegramCommandRoot(args, resolveRoot) {
-    const indexes = args.flatMap((value, index) => value === '--project-root' ? [index] : []);
-    if (indexes.length === 0)
-        return process.cwd();
-    if (indexes.length !== 1)
-        throw new Error('telegram_project_root_repeated');
-    const value = args[indexes[0] + 1];
-    if (!value || value.startsWith('-'))
-        throw new Error('telegram_project_root_required');
-    if (!path.isAbsolute(value))
-        throw new Error('telegram_project_root_absolute_required');
-    try {
-        const canonical = resolveRoot ? await resolveRoot(value) : await projectRootRealpath(value);
-        if (!path.isAbsolute(canonical) || path.normalize(canonical) !== canonical) {
-            throw new Error('invalid_canonical_project_root');
-        }
-        if (resolveRoot)
-            return canonical;
-        if (canonical === path.parse(canonical).root || !(await fs.stat(canonical)).isDirectory()) {
-            throw new Error('invalid_project_root_directory');
-        }
-        const detected = await projectRoot(canonical);
-        const detectedCanonical = await projectRootRealpath(detected);
-        if (detectedCanonical !== canonical)
-            throw new Error('not_exact_project_root');
-        return canonical;
-    }
-    catch (error) {
-        if (error instanceof Error && error.message.startsWith('telegram_project_root_'))
-            throw error;
-        throw new Error('telegram_project_root_invalid');
-    }
-}
-async function readBoundedTokenStdin() {
-    if (process.stdin.isTTY)
-        throw new Error('telegram_token_stdin_required');
-    process.stdin.setEncoding('utf8');
-    let value = '';
-    for await (const chunk of process.stdin) {
-        value += String(chunk);
-        if (Buffer.byteLength(value, 'utf8') > 1024)
-            throw new Error('telegram_token_stdin_too_large');
-    }
-    const token = value.trim();
-    if (!token)
-        throw new Error('telegram_token_stdin_empty');
-    return token;
-}
-function fail(error, json, supported) {
-    process.exitCode = 1;
-    return emit({
-        schema: 'sks.telegram-command.v1', ok: false, error,
-        ...(supported ? { supported } : {})
-    }, json);
-}
-function telegramSetupFailure(error, json, failureStage) {
-    process.exitCode = 1;
-    return emit({
-        schema: 'sks.telegram-setup-command.v1',
-        ok: false,
-        error,
-        token_stored: false,
-        ...(failureStage ? { failure_stage: failureStage } : {})
-    }, json);
-}
-function telegramIdentityFailure(error) {
-    const message = redactTelegramError(error);
-    const code = error instanceof TelegramApiError ? error.code : null;
-    if (code === 401 || code === 404 || /\b(?:401|404|Unauthorized|Not Found)\b/i.test(message)) {
-        return 'telegram_token_rejected';
-    }
-    if (/telegram_(?:request_)?timeout|timed?\s*out/i.test(message)) {
-        return 'telegram_identity_verification_timeout';
-    }
-    if (/fetch failed|network|ENOTFOUND|ECONN|EAI_AGAIN|offline/i.test(message)) {
-        return 'telegram_identity_verification_network_failed';
-    }
-    if (message === 'telegram_token_invalid')
-        return message;
-    return 'telegram_identity_verification_failed';
-}
-function publicBotUsername(value) {
-    const normalized = String(value ?? '').trim();
-    return /^[A-Za-z0-9_]{5,64}$/.test(normalized) ? normalized : null;
-}
-function telegramSetupPartialFailure(input, json) {
-    process.exitCode = 1;
-    return emit({
-        schema: 'sks.telegram-setup-command.v1',
-        ok: false,
-        partial_success: true,
-        error: input.error,
-        detail: input.detail,
-        getme_verified: true,
-        token_stored: false,
-        token_source: 'unchanged',
-        webhook_removed: input.webhookRemoved,
-        pending_updates_dropped: false,
-        bot_id: input.botId,
-        bot_rotated: input.binding?.rotated ?? false,
-        bot_state_reset: input.binding?.state_reset ?? false,
-        restart_required: false,
-        recovery: {
-            action: 'rerun_secure_setup',
-            command: 'sks telegram setup --token-stdin',
-            note: 'The token was not printed or stored. Supply it again through non-TTY standard input.'
-        }
-    }, json);
-}
-function telegramSetupEnvOverrideBlocked(json) {
-    process.exitCode = 1;
-    return emit({
-        schema: 'sks.telegram-setup-command.v1',
-        ok: false,
-        partial_success: false,
-        error: 'telegram_operator_env_override_active',
-        token_source: 'env',
-        token_stored: false,
-        storage_attempted: false,
-        webhook_removed: false,
-        pending_updates_dropped: false,
-        operator_action: 'Remove the operator-managed Telegram token environment override before storing a file token, or keep managing the bot through that environment source.'
-    }, json);
-}
-function emit(value, _json) {
-    console.log(JSON.stringify(value, null, 2));
-    return value;
-}

package/dist/core/telegram/access.js

@@ -1,58 +0,0 @@
-import { randomInt, randomUUID } from 'node:crypto';
-import { SYSTEM_TELEGRAM_CLOCK } from './types.js';
-export class InMemoryTelegramAccessStore {
-    clock;
-    pairings = new Map();
-    chats = new Map();
-    transactionTail = Promise.resolve();
-    constructor(clock = SYSTEM_TELEGRAM_CLOCK) {
-        this.clock = clock;
-    }
-    async issuePairingCode(ttlMs = 5 * 60_000) {
-        return this.transaction(async () => {
-            this.expireCodes();
-            const code = `${randomInt(100_000, 1_000_000)}-${randomUUID().slice(0, 4).toUpperCase()}`;
-            const expiresAt = this.clock.now() + Math.max(30_000, Math.min(ttlMs, 15 * 60_000));
-            this.pairings.set(code, { code, expiresAt, used: false });
-            return { code, expires_at: new Date(expiresAt).toISOString() };
-        });
-    }
-    async pairAtomically(input) {
-        return this.transaction(async () => {
-            const record = this.pairings.get(input.code);
-            if (input.chatType !== 'private'
-                || !Number.isSafeInteger(input.chatId) || input.chatId <= 0
-                || !Number.isSafeInteger(input.senderId) || input.senderId <= 0
-                || !record || record.used || record.expiresAt <= this.clock.now())
-                return false;
-            record.used = true;
-            this.chats.clear();
-            this.chats.set(input.chatId, {
-                chatId: input.chatId,
-                senderId: input.senderId,
-                pairedAt: new Date(this.clock.now()).toISOString()
-            });
-            return true;
-        });
-    }
-    async authorized(chatId, senderId) {
-        return this.transaction(async () => {
-            const chat = this.chats.get(chatId);
-            return chat?.senderId === senderId;
-        });
-    }
-    async authorizedCount() {
-        return this.transaction(async () => this.chats.size);
-    }
-    expireCodes() {
-        for (const [code, record] of this.pairings) {
-            if (record.used || record.expiresAt <= this.clock.now())
-                this.pairings.delete(code);
-        }
-    }
-    transaction(operation) {
-        const next = this.transactionTail.then(operation, operation);
-        this.transactionTail = next.then(() => undefined, () => undefined);
-        return next;
-    }
-}

package/dist/core/telegram/client.js

@@ -1,157 +0,0 @@
-import { redactTelegramError } from './redaction.js';
-export class TelegramApiError extends Error {
-    code;
-    retryAfterSeconds;
-    constructor(message, code = null, retryAfterSeconds = null) {
-        super(message);
-        this.name = 'TelegramApiError';
-        this.code = code;
-        this.retryAfterSeconds = retryAfterSeconds;
-    }
-}
-export class TelegramClient {
-    tokenProvider;
-    fetchImpl;
-    baseUrl;
-    requestTimeoutMs;
-    constructor(options) {
-        this.tokenProvider = options.tokenProvider;
-        this.fetchImpl = options.fetch ?? globalThis.fetch;
-        this.baseUrl = validatedBaseUrl(options.baseUrl ?? 'https://api.telegram.org', options.allowInsecureLocalhost === true);
-        this.requestTimeoutMs = Math.max(1_000, Math.min(options.requestTimeoutMs ?? 20_000, 120_000));
-    }
-    getMe(signal) {
-        return this.call('getMe', {}, signal);
-    }
-    async getWebhookInfo(signal) {
-        const info = await this.call('getWebhookInfo', {}, signal);
-        if (!info || typeof info.url !== 'string')
-            throw new TelegramApiError('telegram_webhook_info_invalid');
-        return info;
-    }
-    async deleteWebhook(signal) {
-        const removed = await this.call('deleteWebhook', {
-            drop_pending_updates: false
-        }, signal);
-        if (removed !== true)
-            throw new TelegramApiError('telegram_delete_webhook_failed');
-    }
-    getUpdates(input) {
-        if (!Number.isSafeInteger(input.offset) || input.offset < 0) {
-            return Promise.reject(new TelegramApiError('telegram_offset_invalid'));
-        }
-        const timeoutSeconds = Number.isFinite(input.timeoutSeconds)
-            ? Math.max(0, Math.min(50, Math.floor(input.timeoutSeconds)))
-            : 0;
-        return this.call('getUpdates', {
-            offset: input.offset,
-            timeout: timeoutSeconds,
-            allowed_updates: [...(input.allowedUpdates ?? ['message'])]
-        }, input.signal, Math.max(this.requestTimeoutMs, Math.min(70_000, (timeoutSeconds * 1_000) + 10_000)));
-    }
-    sendMessage(chatId, text, signal) {
-        if (!Number.isSafeInteger(chatId))
-            return Promise.reject(new TelegramApiError('telegram_chat_id_invalid'));
-        const bounded = text.slice(0, 4_000);
-        if (!bounded)
-            return Promise.reject(new TelegramApiError('telegram_message_empty'));
-        return this.call('sendMessage', { chat_id: chatId, text: bounded }, signal);
-    }
-    async call(method, body, signal, timeoutMs = this.requestTimeoutMs) {
-        const token = String(await this.tokenProvider.loadToken() ?? '').trim();
-        if (!token)
-            throw new TelegramApiError('telegram_token_unavailable');
-        if (!/^\d+:[A-Za-z0-9_-]+$/.test(token))
-            throw new TelegramApiError('telegram_token_invalid');
-        const endpoint = new URL(`/bot${token}/${method}`, this.baseUrl);
-        const requestController = new AbortController();
-        let timedOut = false;
-        const timer = setTimeout(() => {
-            timedOut = true;
-            requestController.abort(new Error('telegram_request_timeout'));
-        }, timeoutMs);
-        const abort = () => requestController.abort(signal?.reason);
-        if (signal?.aborted)
-            requestController.abort(signal.reason);
-        else
-            signal?.addEventListener('abort', abort, { once: true });
-        try {
-            const response = await this.fetchImpl(endpoint, {
-                method: 'POST',
-                headers: { 'content-type': 'application/json; charset=utf-8' },
-                body: JSON.stringify(body),
-                redirect: 'error',
-                signal: requestController.signal
-            });
-            const decoded = await decodeBoundedJson(response);
-            if (!response.ok || !decoded.ok) {
-                const failure = decoded.ok ? null : decoded;
-                throw new TelegramApiError(redactTelegramError(failure?.description || `telegram_http_${response.status}`, token), failure?.error_code ?? response.status, failure?.parameters?.retry_after ?? null);
-            }
-            return decoded.result;
-        }
-        catch (error) {
-            if (error instanceof TelegramApiError)
-                throw error;
-            if (timedOut)
-                throw new TelegramApiError('telegram_request_timeout');
-            if (signal?.aborted)
-                throw error;
-            throw new TelegramApiError(redactTelegramError(error, token));
-        }
-        finally {
-            clearTimeout(timer);
-            signal?.removeEventListener('abort', abort);
-        }
-    }
-}
-async function decodeBoundedJson(response) {
-    const maximum = 2 * 1024 * 1024;
-    const declared = Number(response.headers.get('content-length') ?? '0');
-    if (Number.isFinite(declared) && declared > maximum)
-        throw new TelegramApiError('telegram_response_too_large');
-    const reader = response.body?.getReader();
-    let text = '';
-    if (reader) {
-        const decoder = new TextDecoder();
-        let bytes = 0;
-        while (true) {
-            const chunk = await reader.read();
-            if (chunk.done)
-                break;
-            bytes += chunk.value.byteLength;
-            if (bytes > maximum) {
-                await reader.cancel().catch(() => undefined);
-                throw new TelegramApiError('telegram_response_too_large');
-            }
-            text += decoder.decode(chunk.value, { stream: true });
-        }
-        text += decoder.decode();
-    }
-    else {
-        text = await response.text();
-        if (Buffer.byteLength(text, 'utf8') > maximum)
-            throw new TelegramApiError('telegram_response_too_large');
-    }
-    try {
-        const value = JSON.parse(text);
-        if (!value || typeof value !== 'object' || typeof value.ok !== 'boolean'
-            || (value.ok && !('result' in value))) {
-            throw new Error('shape');
-        }
-        return value;
-    }
-    catch {
-        throw new TelegramApiError('telegram_response_invalid');
-    }
-}
-function validatedBaseUrl(raw, allowInsecureLocalhost) {
-    const url = new URL(raw);
-    const local = url.hostname === '127.0.0.1' || url.hostname === 'localhost' || url.hostname === '::1';
-    if (url.username || url.password || url.search || url.hash)
-        throw new Error('telegram_base_url_invalid');
-    if (url.protocol !== 'https:' && !(allowInsecureLocalhost && local && url.protocol === 'http:')) {
-        throw new Error('telegram_base_url_https_required');
-    }
-    return url;
-}