mikrotik-telegram 0.1.0

package/dist/config.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const PackageConfigSchema: z.ZodObject<{
+    mikrotik: z.ZodObject<{
+        host: z.ZodString;
+        username: z.ZodString;
+        password: z.ZodString;
+        port: z.ZodDefault<z.ZodNumber>;
+        https: z.ZodDefault<z.ZodBoolean>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    telegram: z.ZodObject<{
+        token: z.ZodString;
+        allowedChatIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        webhookSecret: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    security: z.ZodDefault<z.ZodObject<{
+        confirmationTtlSeconds: z.ZodDefault<z.ZodNumber>;
+        defaultRole: z.ZodDefault<z.ZodEnum<{
+            admin: "admin";
+            operator: "operator";
+            viewer: "viewer";
+        }>>;
+        adminChatIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        operatorChatIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PackageConfig = z.infer<typeof PackageConfigSchema>;
+export declare function createConfig(input: unknown): PackageConfig;
+export declare function createConfigFromEnv(env: Record<string, string | undefined>): PackageConfig;

package/dist/config.js

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+const BooleanSchema = z.preprocess((value) => {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'string')
+        return value.toLowerCase() === 'true' || value === '1';
+    return value;
+}, z.boolean());
+export const PackageConfigSchema = z.object({
+    mikrotik: z.object({
+        host: z.string().min(1),
+        username: z.string().min(1),
+        password: z.string().min(1),
+        port: z.number().int().min(1).max(65535).default(80),
+        https: z.boolean().default(false),
+        timeoutMs: z.number().int().positive().default(10_000),
+    }),
+    telegram: z.object({
+        token: z.string().min(1),
+        allowedChatIds: z.array(z.string()).default([]),
+        webhookSecret: z.string().min(16).optional(),
+    }),
+    security: z.object({
+        confirmationTtlSeconds: z.number().int().positive().default(60),
+        defaultRole: z.enum(['admin', 'operator', 'viewer']).default('viewer'),
+        adminChatIds: z.array(z.string()).default([]),
+        operatorChatIds: z.array(z.string()).default([]),
+    }).default({
+        confirmationTtlSeconds: 60,
+        defaultRole: 'viewer',
+        adminChatIds: [],
+        operatorChatIds: [],
+    }),
+});
+export function createConfig(input) {
+    return PackageConfigSchema.parse(input);
+}
+export function createConfigFromEnv(env) {
+    const allowedChatIds = (env.TELEGRAM_ALLOWED_CHAT_IDS || env.TELEGRAM_CHAT_ID || '')
+        .split(',').map((value) => value.trim()).filter(Boolean);
+    const adminChatIds = (env.TELEGRAM_ADMIN_CHAT_IDS || '').split(',').map((value) => value.trim()).filter(Boolean);
+    const operatorChatIds = (env.TELEGRAM_OPERATOR_CHAT_IDS || '').split(',').map((value) => value.trim()).filter(Boolean);
+    return createConfig({
+        mikrotik: {
+            host: env.MIKROTIK_HOST,
+            username: env.MIKROTIK_USER,
+            password: env.MIKROTIK_PASSWORD,
+            port: Number(env.MIKROTIK_HTTP_PORT || 80),
+            https: BooleanSchema.parse(env.MIKROTIK_HTTPS || false),
+            timeoutMs: Number(env.MIKROTIK_TIMEOUT_MS || 10_000),
+        },
+        telegram: {
+            token: env.TELEGRAM_BOT_TOKEN,
+            allowedChatIds,
+            webhookSecret: env.TELEGRAM_WEBHOOK_SECRET,
+        },
+        security: {
+            confirmationTtlSeconds: Number(env.TELEGRAM_CONFIRMATION_TTL_SECONDS || 60),
+            defaultRole: 'viewer',
+            adminChatIds,
+            operatorChatIds,
+        },
+    });
+}

package/dist/errors.d.ts

@@ -0,0 +1,17 @@
+export declare class NetPulseError extends Error {
+    readonly code: string;
+    readonly details?: unknown | undefined;
+    constructor(message: string, code: string, details?: unknown | undefined);
+}
+export declare class RouterOsHttpError extends NetPulseError {
+    readonly status: number;
+    readonly endpoint: string;
+    constructor(status: number, message: string, endpoint: string, details?: unknown);
+}
+export declare class AuthorizationError extends NetPulseError {
+    constructor(message?: string);
+}
+export declare class ConfirmationRequiredError extends NetPulseError {
+    readonly confirmationId: string;
+    constructor(confirmationId: string, message?: string);
+}

package/dist/errors.js

@@ -0,0 +1,34 @@
+export class NetPulseError extends Error {
+    code;
+    details;
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'NetPulseError';
+    }
+}
+export class RouterOsHttpError extends NetPulseError {
+    status;
+    endpoint;
+    constructor(status, message, endpoint, details) {
+        super(message, 'ROUTEROS_HTTP_ERROR', details);
+        this.status = status;
+        this.endpoint = endpoint;
+        this.name = 'RouterOsHttpError';
+    }
+}
+export class AuthorizationError extends NetPulseError {
+    constructor(message = 'Commande non autorisée.') {
+        super(message, 'TELEGRAM_UNAUTHORIZED');
+        this.name = 'AuthorizationError';
+    }
+}
+export class ConfirmationRequiredError extends NetPulseError {
+    confirmationId;
+    constructor(confirmationId, message = 'Confirmation requise.') {
+        super(message, 'CONFIRMATION_REQUIRED');
+        this.confirmationId = confirmationId;
+        this.name = 'ConfirmationRequiredError';
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from './config';
+export * from './errors';
+export * from './rest-client';
+export * from './mikrotik-service';
+export * from './telegram-client';
+export * from './telegram-commands';
+export * from './runtime';
+export * from './runtime-adapters';
+export * from './alerts';
+export * from './automation';
+export * from './actions';
+export * from './types';
+export * from './audit';

package/dist/index.js

@@ -0,0 +1,13 @@
+export * from './config';
+export * from './errors';
+export * from './rest-client';
+export * from './mikrotik-service';
+export * from './telegram-client';
+export * from './telegram-commands';
+export * from './runtime';
+export * from './runtime-adapters';
+export * from './alerts';
+export * from './automation';
+export * from './actions';
+export * from './types';
+export * from './audit';

package/dist/mikrotik-service.d.ts

@@ -0,0 +1,27 @@
+import { RouterOsRestClient } from './rest-client';
+import type { ActiveSession, CreateHotspotUserInput, CreateProfileInput, CreateSchedulerInput, CreateScriptInput, HotspotProfile, HotspotUser, MutationResult, RouterId, RouterScheduler, RouterScript, SystemHealth, UpdateHotspotUserInput, UpdateProfileInput, UpdateSchedulerInput, UserQuery, GenerateVouchersInput, GenerateVouchersResult, BanUserInput, BanResult, UnbanUserInput, DeleteUserInput, DisconnectUserInput } from './types';
+export declare class MikroTikService {
+    private readonly client;
+    constructor(client: RouterOsRestClient);
+    getSystemHealth(): Promise<SystemHealth>;
+    listHotspotUsers(query?: UserQuery): Promise<HotspotUser[]>;
+    createHotspotUser(input: CreateHotspotUserInput): Promise<HotspotUser>;
+    generateVouchers(input: GenerateVouchersInput): Promise<GenerateVouchersResult>;
+    updateHotspotUser(id: RouterId, input: UpdateHotspotUserInput): Promise<HotspotUser>;
+    deleteHotspotUser(id: RouterId): Promise<MutationResult>;
+    listProfiles(): Promise<HotspotProfile[]>;
+    createProfile(input: CreateProfileInput): Promise<HotspotProfile>;
+    updateProfile(id: RouterId, input: UpdateProfileInput): Promise<HotspotProfile>;
+    deleteProfile(id: RouterId): Promise<MutationResult>;
+    listActiveSessions(): Promise<ActiveSession[]>;
+    disconnectSession(id: RouterId): Promise<MutationResult>;
+    banUser(input: BanUserInput): Promise<BanResult>;
+    unbanUser(input: UnbanUserInput): Promise<MutationResult>;
+    deleteUser(input: DeleteUserInput): Promise<MutationResult>;
+    disconnectUser(input: DisconnectUserInput): Promise<MutationResult>;
+    createScript(input: CreateScriptInput): Promise<RouterScript>;
+    runScript(id: RouterId): Promise<MutationResult>;
+    createScheduler(input: CreateSchedulerInput): Promise<RouterScheduler>;
+    updateScheduler(id: RouterId, input: UpdateSchedulerInput): Promise<RouterScheduler>;
+    deleteScheduler(id: RouterId): Promise<MutationResult>;
+}

package/dist/mikrotik-service.js

@@ -0,0 +1,225 @@
+import { z } from 'zod';
+const RouterIdSchema = z.string().min(1);
+const UserSchema = z.object({
+    name: z.string().min(1).max(64), password: z.string().min(1).max(128), profile: z.string().min(1),
+    comment: z.string().max(255).optional(), limitUptime: z.string().min(1).optional(),
+});
+const ProfileSchema = z.object({
+    name: z.string().min(1).max(64), rateLimit: z.string().max(128).optional(),
+    sharedUsers: z.number().int().positive().optional(), onLogin: z.string().max(4096).optional(),
+});
+const ScriptSchema = z.object({ name: z.string().min(1).max(64), source: z.string().min(1), comment: z.string().max(255).optional() });
+const SchedulerSchema = z.object({
+    name: z.string().min(1).max(64), interval: z.string().min(1), onEvent: z.string().min(1),
+    comment: z.string().max(255).optional(), disabled: z.boolean().optional(),
+});
+const VoucherGenerationSchema = z.object({
+    count: z.number().int().min(1).max(500), length: z.number().int().min(4).max(32).default(6),
+    prefix: z.string().regex(/^[A-Za-z0-9_-]*$/).max(16).default('NET'), profile: z.string().min(1).default('default'),
+    passwordLength: z.number().int().min(4).max(32).default(8), limitUptime: z.string().min(1).optional(),
+    comment: z.string().max(255).optional(), price: z.number().nonnegative().optional(), expiresAt: z.string().datetime().optional(),
+    dryRun: z.boolean().default(false), duplicateCheck: z.boolean().default(true),
+});
+const IpAddressSchema = z.string().trim().refine((value) => /^((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/.test(value), 'Adresse IP invalide');
+const BanSchema = z.object({
+    address: IpAddressSchema.optional(), user: z.string().min(1).optional(), comment: z.string().max(255).optional(), timeout: z.string().min(1).default('1d'),
+}).refine((value) => Boolean(value.address || value.user), 'address ou user est requis');
+const UnbanSchema = z.object({ ruleId: z.string().min(1).optional(), address: IpAddressSchema.optional() }).refine((value) => Boolean(value.ruleId || value.address), 'ruleId ou address est requis');
+function idOf(record) {
+    const id = record['.id'] || record.ret || record.id;
+    return RouterIdSchema.parse(id);
+}
+function userOf(record) {
+    return { id: idOf(record), name: record.name || '', password: record.password, profile: record.profile, comment: record.comment, limitUptime: record['limit-uptime'], uptime: record.uptime };
+}
+function randomCode(length) {
+    const alphabet = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789';
+    return Array.from({ length }, () => alphabet[Math.floor(Math.random() * alphabet.length)]).join('');
+}
+export class MikroTikService {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async getSystemHealth() {
+        const started = Date.now();
+        const [resource, identity, board] = await Promise.all([
+            this.client.get('/system/resource'),
+            this.client.list('/system/identity'),
+            this.client.list('/system/routerboard'),
+        ]);
+        const metrics = resource;
+        return {
+            identity: identity[0]?.name || 'Unknown', model: metrics['board-name'] || board[0]?.model || 'Unknown',
+            version: metrics.version || 'Unknown', uptime: metrics.uptime || 'Unknown',
+            cpuLoadPercent: Number(metrics['cpu-load'] || 0), totalMemoryBytes: Number(metrics['total-memory'] || 0),
+            freeMemoryBytes: Number(metrics['free-memory'] || 0), totalStorageBytes: Number(metrics['total-hdd-space'] || 0),
+            freeStorageBytes: Number(metrics['free-hdd-space'] || 0), latencyMs: Date.now() - started,
+        };
+    }
+    async listHotspotUsers(query = {}) {
+        const params = new URLSearchParams();
+        if (query.name)
+            params.set('name', query.name);
+        if (query.profile)
+            params.set('profile', query.profile);
+        const records = await this.client.list(`/ip/hotspot/user${params.size ? `?${params}` : ''}`);
+        return records.slice(0, query.limit || records.length).map(userOf);
+    }
+    async createHotspotUser(input) {
+        const data = UserSchema.parse({ profile: 'default', ...input });
+        const record = await this.client.create('/ip/hotspot/user/add', {
+            name: data.name, password: data.password, profile: data.profile,
+            ...(data.comment ? { comment: data.comment } : {}), ...(data.limitUptime ? { 'limit-uptime': data.limitUptime } : {}),
+        });
+        const id = idOf(record);
+        return userOf({ ...record, '.id': id, name: data.name, password: data.password, profile: data.profile });
+    }
+    async generateVouchers(input) {
+        const data = VoucherGenerationSchema.parse(input);
+        const existingNames = data.duplicateCheck ? new Set((await this.listHotspotUsers()).map((user) => user.name)) : new Set();
+        const vouchers = [];
+        let duplicateSkipped = 0;
+        for (let index = 0; index < data.count; index += 1) {
+            let candidate;
+            do {
+                candidate = `${data.prefix}-${randomCode(data.length)}-${index + 1}`;
+            } while (data.duplicateCheck && existingNames.has(candidate));
+            if (data.duplicateCheck && existingNames.has(candidate)) {
+                duplicateSkipped += 1;
+                continue;
+            }
+            existingNames.add(candidate);
+            vouchers.push({
+                name: candidate,
+                password: randomCode(data.passwordLength),
+                profile: data.profile,
+                price: data.price,
+                expiresAt: data.expiresAt,
+                created: false,
+            });
+        }
+        if (data.dryRun) {
+            return { requested: data.count, created: 0, dryRun: true, duplicateSkipped, vouchers: vouchers.map((voucher) => ({ ...voucher, created: false })) };
+        }
+        const created = await Promise.all(vouchers.map(async (voucher) => {
+            const metadata = [data.comment, data.price ? `price=${data.price}` : undefined, data.expiresAt ? `expires=${data.expiresAt}` : undefined].filter(Boolean).join(' | ');
+            await this.createHotspotUser({
+                name: voucher.name,
+                password: voucher.password,
+                profile: voucher.profile,
+                limitUptime: data.limitUptime,
+                comment: metadata || data.comment,
+            });
+            return { ...voucher, created: true };
+        }));
+        return { requested: data.count, created: created.length, dryRun: false, duplicateSkipped, vouchers: created };
+    }
+    async updateHotspotUser(id, input) {
+        const validId = RouterIdSchema.parse(id);
+        const data = UserSchema.partial().parse(input);
+        await this.client.update('/ip/hotspot/user', validId, {
+            ...(data.name ? { name: data.name } : {}), ...(data.password ? { password: data.password } : {}),
+            ...(data.profile ? { profile: data.profile } : {}), ...(data.comment !== undefined ? { comment: data.comment } : {}),
+            ...(data.limitUptime ? { 'limit-uptime': data.limitUptime } : {}),
+        });
+        const updated = await this.client.get(`/ip/hotspot/user/${encodeURIComponent(validId)}`);
+        return userOf({ ...updated, '.id': validId });
+    }
+    async deleteHotspotUser(id) {
+        const validId = RouterIdSchema.parse(id);
+        await this.client.remove('/ip/hotspot/user', validId);
+        return { success: true, id: validId, operation: 'delete-hotspot-user' };
+    }
+    async listProfiles() {
+        const records = await this.client.list('/ip/hotspot/user/profile');
+        return records.map((record) => ({ id: idOf(record), name: record.name || '', rateLimit: record['rate-limit'], sharedUsers: Number(record['shared-users'] || 0), onLogin: record['on-login'] }));
+    }
+    async createProfile(input) {
+        const data = ProfileSchema.parse(input);
+        const record = await this.client.create('/ip/hotspot/user/profile/add', {
+            name: data.name, ...(data.rateLimit ? { 'rate-limit': data.rateLimit } : {}),
+            ...(data.sharedUsers ? { 'shared-users': data.sharedUsers } : {}), ...(data.onLogin ? { 'on-login': data.onLogin } : {}),
+        });
+        return { id: idOf(record), name: data.name, rateLimit: data.rateLimit, sharedUsers: data.sharedUsers, onLogin: data.onLogin };
+    }
+    async updateProfile(id, input) {
+        const validId = RouterIdSchema.parse(id);
+        const data = ProfileSchema.partial().parse(input);
+        const record = await this.client.update('/ip/hotspot/user/profile', validId, {
+            ...(data.name ? { name: data.name } : {}), ...(data.rateLimit ? { 'rate-limit': data.rateLimit } : {}),
+            ...(data.sharedUsers ? { 'shared-users': data.sharedUsers } : {}), ...(data.onLogin ? { 'on-login': data.onLogin } : {}),
+        });
+        return { id: validId, name: record.name || data.name || '', rateLimit: record['rate-limit'] || data.rateLimit, sharedUsers: Number(record['shared-users'] || data.sharedUsers || 0), onLogin: record['on-login'] || data.onLogin };
+    }
+    async deleteProfile(id) {
+        const validId = RouterIdSchema.parse(id);
+        await this.client.remove('/ip/hotspot/user/profile', validId);
+        return { success: true, id: validId, operation: 'delete-profile' };
+    }
+    async listActiveSessions() {
+        const records = await this.client.list('/ip/hotspot/active');
+        return records.map((record) => ({ id: idOf(record), user: record.user || '', address: record.address, macAddress: record['mac-address'], uptime: record.uptime, sessionTimeLeft: record['session-time-left'], bytesIn: Number(record['bytes-in'] || 0), bytesOut: Number(record['bytes-out'] || 0) }));
+    }
+    async disconnectSession(id) {
+        const validId = RouterIdSchema.parse(id);
+        await this.client.remove('/ip/hotspot/active', validId);
+        return { success: true, id: validId, operation: 'disconnect-session' };
+    }
+    async banUser(input) {
+        const data = BanSchema.parse(input);
+        const comment = data.comment || `NetPulse ban${data.user ? ` user=${data.user}` : ''}`;
+        const record = await this.client.create('/ip/firewall/address-list/add', {
+            list: 'netpulse-ban', address: data.address || data.user, timeout: data.timeout, comment,
+        });
+        const ruleId = idOf(record);
+        return { success: true, operation: 'ban-user', address: data.address, ruleId };
+    }
+    async unbanUser(input) {
+        const data = UnbanSchema.parse(input);
+        const ruleId = data.ruleId || (await this.client.findOne('/ip/firewall/address-list', 'address', data.address || ''))?.['.id'];
+        if (!ruleId)
+            return { success: false, operation: 'unban-user' };
+        await this.client.remove('/ip/firewall/address-list', ruleId);
+        return { success: true, id: ruleId, operation: 'unban-user' };
+    }
+    async deleteUser(input) {
+        const id = RouterIdSchema.parse(input.id);
+        return this.deleteHotspotUser(id);
+    }
+    async disconnectUser(input) {
+        const sessionId = RouterIdSchema.parse(input.sessionId);
+        return this.disconnectSession(sessionId);
+    }
+    async createScript(input) {
+        const data = ScriptSchema.parse(input);
+        const record = await this.client.create('/system/script/add', data);
+        return { id: idOf(record), name: data.name, source: data.source, comment: data.comment };
+    }
+    async runScript(id) {
+        const validId = RouterIdSchema.parse(id);
+        await this.client.request('POST', '/system/script/run', { '.id': validId });
+        return { success: true, id: validId, operation: 'run-script' };
+    }
+    async createScheduler(input) {
+        const data = SchedulerSchema.parse(input);
+        const record = await this.client.create('/system/scheduler/add', {
+            name: data.name, interval: data.interval, 'on-event': data.onEvent, disabled: data.disabled ? 'yes' : 'no', ...(data.comment ? { comment: data.comment } : {}),
+        });
+        return { id: idOf(record), name: data.name, interval: data.interval, onEvent: data.onEvent, disabled: Boolean(data.disabled) };
+    }
+    async updateScheduler(id, input) {
+        const validId = RouterIdSchema.parse(id);
+        const data = SchedulerSchema.partial().parse(input);
+        const record = await this.client.update('/system/scheduler', validId, {
+            ...(data.name ? { name: data.name } : {}), ...(data.interval ? { interval: data.interval } : {}), ...(data.onEvent ? { 'on-event': data.onEvent } : {}),
+            ...(data.comment !== undefined ? { comment: data.comment } : {}), ...(data.disabled !== undefined ? { disabled: data.disabled ? 'yes' : 'no' } : {}),
+        });
+        return { id: validId, name: record.name || data.name || '', interval: record.interval || data.interval || '', onEvent: record['on-event'] || data.onEvent || '', disabled: record.disabled === 'true' || record.disabled === 'yes' };
+    }
+    async deleteScheduler(id) {
+        const validId = RouterIdSchema.parse(id);
+        await this.client.remove('/system/scheduler', validId);
+        return { success: true, id: validId, operation: 'delete-scheduler' };
+    }
+}

package/dist/rest-client.d.ts

@@ -0,0 +1,24 @@
+import type { RouterPayload, RouterRecord, RouterResponse } from './types';
+export interface RestClientOptions {
+    readonly host: string;
+    readonly port: number;
+    readonly username: string;
+    readonly password: string;
+    readonly https?: boolean;
+    readonly timeoutMs?: number;
+    readonly fetch?: typeof fetch;
+}
+export declare class RouterOsRestClient {
+    private readonly baseUrl;
+    private readonly authorization;
+    private readonly requestTimeoutMs;
+    private readonly fetcher;
+    constructor(options: RestClientOptions);
+    request<T extends RouterResponse = RouterResponse>(method: 'GET' | 'POST' | 'PATCH' | 'DELETE', endpoint: string, body?: RouterPayload): Promise<T>;
+    list<T extends RouterRecord = RouterRecord>(endpoint: string): Promise<T[]>;
+    get<T extends RouterRecord = RouterRecord>(endpoint: string): Promise<T>;
+    create<T extends RouterRecord = RouterRecord>(endpoint: string, body: RouterPayload): Promise<T>;
+    update<T extends RouterRecord = RouterRecord>(endpoint: string, id: string, body: RouterPayload): Promise<T>;
+    remove(endpoint: string, id: string): Promise<RouterResponse>;
+    findOne<T extends RouterRecord = RouterRecord>(endpoint: string, field: string, value: string): Promise<T | undefined>;
+}

package/dist/rest-client.js

@@ -0,0 +1,55 @@
+import { RouterOsHttpError } from './errors';
+export class RouterOsRestClient {
+    baseUrl;
+    authorization;
+    requestTimeoutMs;
+    fetcher;
+    constructor(options) {
+        const scheme = options.https ? 'https' : 'http';
+        this.baseUrl = `${scheme}://${options.host}:${options.port}/rest`;
+        this.authorization = `Basic ${btoa(`${options.username}:${options.password}`)}`;
+        this.requestTimeoutMs = options.timeoutMs ?? 10_000;
+        this.fetcher = options.fetch ?? fetch;
+    }
+    async request(method, endpoint, body) {
+        const normalizedEndpoint = endpoint.startsWith('/') ? endpoint : `/${endpoint}`;
+        const response = await this.fetcher(`${this.baseUrl}${normalizedEndpoint}`, {
+            method,
+            headers: { Authorization: this.authorization, 'Content-Type': 'application/json' },
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal: AbortSignal.timeout(this.requestTimeoutMs),
+        });
+        const text = await response.text();
+        let parsed = text;
+        try {
+            parsed = text ? JSON.parse(text) : null;
+        }
+        catch { /* RouterOS may return plain text. */ }
+        if (!response.ok) {
+            const message = response.status === 401
+                ? 'Authentification REST RouterOS refusée.'
+                : `Erreur REST RouterOS HTTP ${response.status}.`;
+            throw new RouterOsHttpError(response.status, message, normalizedEndpoint, parsed);
+        }
+        return parsed;
+    }
+    list(endpoint) {
+        return this.request('GET', endpoint);
+    }
+    get(endpoint) {
+        return this.request('GET', endpoint);
+    }
+    create(endpoint, body) {
+        return this.request('POST', endpoint, body);
+    }
+    update(endpoint, id, body) {
+        return this.request('PATCH', `${endpoint}/${encodeURIComponent(id)}`, body);
+    }
+    remove(endpoint, id) {
+        return this.request('DELETE', `${endpoint}/${encodeURIComponent(id)}`);
+    }
+    async findOne(endpoint, field, value) {
+        const query = `${encodeURIComponent(field)}=${encodeURIComponent(value)}`;
+        return (await this.list(`${endpoint}?${query}`))[0];
+    }
+}

package/dist/runtime-adapters.d.ts

@@ -0,0 +1,56 @@
+import type { TelegramUpdate } from './types';
+export interface RuntimeAdapter {
+    readonly fetch: typeof fetch;
+    now(): Date;
+    sleep(milliseconds: number): Promise<void>;
+}
+export interface BotRuntimeConfig {
+    readonly token: string;
+    readonly allowedChatIds?: readonly string[];
+    readonly adminChatIds?: readonly string[];
+    readonly operatorChatIds?: readonly string[];
+    readonly webhookSecret?: string;
+    readonly onUpdate?: (update: TelegramUpdate, runtime: RuntimeAdapter) => Promise<unknown>;
+}
+export declare function createRuntimeAdapter(fetcher?: typeof fetch): RuntimeAdapter;
+export interface UpdateHandler {
+    (update: TelegramUpdate): Promise<unknown>;
+}
+export interface WebhookHandler {
+    (request: Request): Promise<Response>;
+}
+export interface BotRuntime {
+    readonly token: string;
+    readonly allowedChatIds: readonly string[];
+    readonly adminChatIds: readonly string[];
+    readonly operatorChatIds: readonly string[];
+    readonly handleUpdate: UpdateHandler;
+    readonly createWebhookHandler: (options?: {
+        readonly secret?: string;
+    }) => WebhookHandler;
+}
+export declare function createNodeBot(config: BotRuntimeConfig, runtime?: RuntimeAdapter): BotRuntime;
+export declare function createBunBot(config: BotRuntimeConfig, runtime?: RuntimeAdapter): BotRuntime;
+export declare function createServerlessHandler(handler: UpdateHandler): (request: Request) => Promise<Response>;
+export declare function createWorkerHandler(handler: UpdateHandler): (request: Request) => Promise<Response>;
+export declare function createCronRunner<T = unknown>(runner: () => Promise<T> | T): () => Promise<{
+    ok: boolean;
+    data?: T;
+    id?: string;
+}>;
+export declare function createWorkerRuntime<T = unknown>(runner: () => Promise<T> | T): () => Promise<{
+    ok: boolean;
+    data?: T;
+    id?: string;
+}>;
+export declare function createWebhookHandler(handler: UpdateHandler, options?: {
+    readonly secret?: string;
+}): WebhookHandler;
+export interface PollingTransport {
+    getUpdates(offset?: number, timeoutSeconds?: number): Promise<readonly TelegramUpdate[]>;
+}
+export declare function runPolling(transport: PollingTransport, handler: UpdateHandler, runtime?: RuntimeAdapter, options?: {
+    readonly signal?: AbortSignal;
+    readonly timeoutSeconds?: number;
+    readonly retryMs?: number;
+}): Promise<void>;

package/dist/runtime-adapters.js

@@ -0,0 +1,87 @@
+export function createRuntimeAdapter(fetcher = fetch) {
+    return {
+        fetch: fetcher,
+        now: () => new Date(),
+        sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
+    };
+}
+function buildBotRuntime(config, runtime = createRuntimeAdapter()) {
+    const handleUpdate = async (update) => {
+        const custom = config.onUpdate ?? (async (nextUpdate) => ({ ok: true, update: nextUpdate }));
+        return custom(update, runtime);
+    };
+    return {
+        token: config.token,
+        allowedChatIds: config.allowedChatIds ?? [],
+        adminChatIds: config.adminChatIds ?? [],
+        operatorChatIds: config.operatorChatIds ?? [],
+        handleUpdate,
+        createWebhookHandler: (options = {}) => createWebhookHandler(handleUpdate, { secret: options.secret ?? config.webhookSecret }),
+    };
+}
+export function createNodeBot(config, runtime = createRuntimeAdapter()) {
+    return buildBotRuntime(config, runtime);
+}
+export function createBunBot(config, runtime = createRuntimeAdapter()) {
+    return buildBotRuntime(config, runtime);
+}
+export function createServerlessHandler(handler) {
+    return createWebhookHandler(handler);
+}
+export function createWorkerHandler(handler) {
+    return createWebhookHandler(handler);
+}
+export function createCronRunner(runner) {
+    return async () => {
+        try {
+            const data = await runner();
+            return { ok: true, data, id: 'cron-runner' };
+        }
+        catch (error) {
+            return { ok: false, id: 'cron-runner', data: undefined };
+        }
+    };
+}
+export function createWorkerRuntime(runner) {
+    return async () => {
+        try {
+            const data = await runner();
+            return { ok: true, data, id: 'worker-runtime' };
+        }
+        catch {
+            return { ok: false, id: 'worker-runtime', data: undefined };
+        }
+    };
+}
+export function createWebhookHandler(handler, options = {}) {
+    return async (request) => {
+        if (request.method !== 'POST')
+            return new Response('Method Not Allowed', { status: 405 });
+        if (options.secret && request.headers.get('x-telegram-bot-api-secret-token') !== options.secret) {
+            return new Response('Unauthorized', { status: 401 });
+        }
+        try {
+            const update = await request.json();
+            await handler(update);
+            return Response.json({ ok: true });
+        }
+        catch (error) {
+            return Response.json({ ok: false, error: error instanceof Error ? error.message : String(error) }, { status: 400 });
+        }
+    };
+}
+export async function runPolling(transport, handler, runtime = createRuntimeAdapter(), options = {}) {
+    let offset;
+    while (!options.signal?.aborted) {
+        try {
+            const updates = await transport.getUpdates(offset, options.timeoutSeconds ?? 25);
+            for (const update of updates) {
+                offset = update.update_id + 1;
+                await handler(update);
+            }
+        }
+        catch {
+            await runtime.sleep(options.retryMs ?? 2_000);
+        }
+    }
+}

package/dist/runtime.d.ts

@@ -0,0 +1,10 @@
+import type { PackageConfig } from './config';
+import { MikroTikService } from './mikrotik-service';
+import { TelegramCommandRegistry } from './telegram-commands';
+import type { CommandResponse, TelegramUpdate } from './types';
+export interface NetPulseRuntime {
+    readonly registry: TelegramCommandRegistry;
+    readonly mikrotik: MikroTikService;
+    handleUpdate(update: TelegramUpdate): Promise<CommandResponse | undefined>;
+}
+export declare function createRuntime(config: PackageConfig, fetcher?: typeof fetch): NetPulseRuntime;