nonotify 0.1.0 → 0.1.2

package/.github/workflows/release.yml

@@ -0,0 +1,113 @@
+name: Release & Publish
+
+on:
+  push:
+    branches: [main]
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org/
+
+      - name: Decide whether to release
+        id: guard
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          VERSION="$(node -p "require('./package.json').version")"
+          NAME="$(node -p "require('./package.json').name")"
+
+          git fetch --tags --force
+
+          # Latest tag (empty if no tags yet)
+          LATEST_TAG="$(git tag --sort=-v:refname | head -n 1 || true)"
+
+          # Does tag for this version already exist?
+          if git rev-parse -q --verify "refs/tags/$VERSION" >/dev/null; then
+            TAG_EXISTS="true"
+          else
+            TAG_EXISTS="false"
+          fi
+
+          # Is that version already on npm?
+          if npm view "${NAME}@${VERSION}" version >/dev/null 2>&1; then
+            NPM_EXISTS="true"
+          else
+            NPM_EXISTS="false"
+          fi
+
+          # Decide
+          SHOULD_RELEASE="true"
+          REASON="ok"
+
+          if [[ "$TAG_EXISTS" == "true" ]]; then
+            SHOULD_RELEASE="false"
+            REASON="git tag already exists"
+          elif [[ -n "$LATEST_TAG" && "$VERSION" == "$LATEST_TAG" ]]; then
+            SHOULD_RELEASE="false"
+            REASON="package.json version equals latest tag"
+          elif [[ "$NPM_EXISTS" == "true" ]]; then
+            SHOULD_RELEASE="false"
+            REASON="version already published on npm"
+          fi
+
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+          echo "latest_tag=$LATEST_TAG" >> "$GITHUB_OUTPUT"
+          echo "tag_exists=$TAG_EXISTS" >> "$GITHUB_OUTPUT"
+          echo "npm_exists=$NPM_EXISTS" >> "$GITHUB_OUTPUT"
+          echo "should_release=$SHOULD_RELEASE" >> "$GITHUB_OUTPUT"
+          echo "reason=$REASON" >> "$GITHUB_OUTPUT"
+
+          echo "Decision: should_release=$SHOULD_RELEASE ($REASON)"
+
+      - name: Stop summary
+        if: steps.guard.outputs.should_release != 'true'
+        run: |
+          echo "Skipping release: ${{ steps.guard.outputs.reason }}"
+          echo "Version: ${{ steps.guard.outputs.version }}"
+          echo "Latest tag: ${{ steps.guard.outputs.latest_tag }}"
+
+      - name: Install dependencies
+        if: steps.guard.outputs.should_release == 'true'
+        run: npm ci
+
+      # - name: Run tests
+      #   if: steps.guard.outputs.should_release == 'true'
+      #   run: npm test
+
+      - name: Create git tag
+        if: steps.guard.outputs.should_release == 'true'
+        run: |
+          git config user.name "github-actions"
+          git config user.email "github-actions@github.com"
+          git tag "${{ steps.guard.outputs.version }}"
+          git push origin "${{ steps.guard.outputs.version }}"
+
+      - name: Create GitHub Release
+        if: steps.guard.outputs.should_release == 'true'
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ steps.guard.outputs.version }}
+          name: Release ${{ steps.guard.outputs.version }}
+          generate_release_notes: true
+
+      - name: Publish to npm
+        if: steps.guard.outputs.should_release == 'true'
+        run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.npm_token }}

package/README.md

@@ -7,12 +7,10 @@ Use it to send yourself a message when tasks are done, including from coding age
 ## Install
 
 ```bash
-npm install
-npm run build
-npm link
+npm install -g nonotify
 ```
 
-After linking, `nnt` is available globally.
+After install, `nnt` is available globally.
 
 ## Config location
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nonotify",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "nnt CLI for Telegram notifications",
   "type": "module",
   "bin": {

package/dist/cli.js

@@ -1,420 +0,0 @@
-#!/usr/bin/env node
-import { Cli, z } from 'incur';
-import { askConfirm, askRequired, askRequiredWithInitial, askSelect } from './prompt.js';
-import { getConfigPath, loadConfig, saveConfig } from './config.js';
-import { printKeyValueTable, printProfilesTable } from './display.js';
-import { getLatestUpdateOffset, sendTelegramMessage, waitForChatId } from './telegram.js';
-const profileCli = Cli.create('profile', {
-    description: 'Manage notification profiles',
-});
-profileCli.command('add', {
-    description: 'Add a notification profile',
-    outputPolicy: 'agent-only',
-    args: z.object({
-        provider: z.enum(['telegram']).default('telegram').describe('Profile provider'),
-    }),
-    async run(c) {
-        if (c.args.provider !== 'telegram') {
-            throw new Error(`Unsupported provider: ${c.args.provider}`);
-        }
-        const config = await loadConfig();
-        const profileName = await askRequired('Profile name: ');
-        if (config.profiles[profileName]) {
-            throw new Error(`Profile "${profileName}" already exists.`);
-        }
-        const botToken = await askRequired('Telegram bot token: ');
-        if (shouldRenderPretty(c.agent)) {
-            process.stdout.write('\nSend any message to your bot in Telegram.\n');
-            process.stdout.write('Waiting for message to detect chat_id (up to 120s)...\n');
-        }
-        const offset = await getLatestUpdateOffset(botToken);
-        const connection = await waitForChatId(botToken, offset, 120);
-        const chatId = connection.chatId;
-        if (shouldRenderPretty(c.agent)) {
-            if (connection.username) {
-                process.stdout.write(`Connected Telegram username: @${connection.username}\n`);
-            }
-            else {
-                process.stdout.write('Connected Telegram user has no username set.\n');
-            }
-        }
-        config.profiles[profileName] = {
-            type: 'telegram',
-            name: profileName,
-            botToken,
-            chatId,
-            createdAt: new Date().toISOString(),
-        };
-        if (!config.defaultProfile) {
-            config.defaultProfile = profileName;
-        }
-        await saveConfig(config);
-        let confirmationSent = false;
-        let confirmationWarning = null;
-        try {
-            await sendTelegramMessage(botToken, chatId, `nnt: profile "${profileName}" connected successfully. You can now send notifications from CLI.`);
-            confirmationSent = true;
-        }
-        catch (error) {
-            confirmationWarning = error instanceof Error ? error.message : 'Unknown error while sending confirmation';
-        }
-        if (shouldRenderPretty(c.agent)) {
-            printKeyValueTable('Profile added', [
-                { key: 'profile', value: profileName },
-                { key: 'provider', value: 'telegram' },
-                { key: 'chat_id', value: chatId },
-                { key: 'username', value: connection.username ? `@${connection.username}` : '(none)' },
-                { key: 'default', value: config.defaultProfile ?? '(none)' },
-            ]);
-        }
-        return {
-            added: true,
-            profile: profileName,
-            provider: 'telegram',
-            chatId,
-            username: connection.username,
-            defaultProfile: config.defaultProfile,
-            configPath: getConfigPath(),
-            confirmationSent,
-            confirmationWarning,
-        };
-    },
-});
-profileCli.command('list', {
-    description: 'List configured profiles',
-    outputPolicy: 'agent-only',
-    async run(c) {
-        const config = await loadConfig();
-        const names = Object.keys(config.profiles).sort((a, b) => a.localeCompare(b));
-        const profiles = names.map(name => ({
-            name,
-            provider: config.profiles[name].type,
-            isDefault: name === config.defaultProfile,
-        }));
-        if (shouldRenderPretty(c.agent)) {
-            printProfilesTable(profiles);
-        }
-        return {
-            defaultProfile: config.defaultProfile,
-            totalProfiles: names.length,
-            profiles,
-        };
-    },
-});
-profileCli.command('default', {
-    description: 'Get or set default profile',
-    outputPolicy: 'agent-only',
-    args: z.object({
-        profile: z.string().optional().describe('Profile name to set as default'),
-    }),
-    async run(c) {
-        const config = await loadConfig();
-        if (!c.args.profile) {
-            if (shouldRenderPretty(c.agent)) {
-                printKeyValueTable('Default profile', [
-                    { key: 'default', value: config.defaultProfile ?? '(not set)' },
-                ]);
-            }
-            return {
-                defaultProfile: config.defaultProfile,
-            };
-        }
-        if (!config.profiles[c.args.profile]) {
-            throw new Error(`Profile "${c.args.profile}" not found.`);
-        }
-        config.defaultProfile = c.args.profile;
-        await saveConfig(config);
-        if (shouldRenderPretty(c.agent)) {
-            printKeyValueTable('Default profile updated', [
-                { key: 'default', value: config.defaultProfile ?? '(not set)' },
-            ]);
-        }
-        return {
-            updated: true,
-            defaultProfile: config.defaultProfile,
-        };
-    },
-});
-profileCli.command('delete', {
-    description: 'Delete a profile',
-    outputPolicy: 'agent-only',
-    args: z.object({
-        profile: z.string().describe('Profile name to delete'),
-    }),
-    async run(c) {
-        const config = await loadConfig();
-        const targetName = c.args.profile;
-        const profile = config.profiles[targetName];
-        if (!profile) {
-            throw new Error(`Profile "${targetName}" not found.`);
-        }
-        delete config.profiles[targetName];
-        if (config.defaultProfile === targetName) {
-            const remaining = Object.keys(config.profiles).sort((a, b) => a.localeCompare(b));
-            config.defaultProfile = remaining[0] ?? null;
-        }
-        await saveConfig(config);
-        if (shouldRenderPretty(c.agent)) {
-            printKeyValueTable('Profile deleted', [
-                { key: 'profile', value: targetName },
-                { key: 'provider', value: profile.type },
-                { key: 'default', value: config.defaultProfile ?? '(not set)' },
-            ]);
-        }
-        return {
-            deleted: true,
-            profile: targetName,
-            provider: profile.type,
-            defaultProfile: config.defaultProfile,
-        };
-    },
-});
-profileCli.command('edit', {
-    description: 'Edit profile data',
-    outputPolicy: 'agent-only',
-    args: z.object({
-        profile: z.string().optional().describe('Existing profile name'),
-    }),
-    options: z.object({
-        newName: z.string().optional().describe('Rename profile to a new name'),
-        botToken: z.string().optional().describe('Replace Telegram bot token'),
-        chatId: z.string().optional().describe('Replace Telegram chat id'),
-        reconnect: z.boolean().optional().describe('Re-detect chat id from next Telegram message'),
-    }),
-    alias: {
-        newName: 'n',
-        botToken: 't',
-        chatId: 'c',
-        reconnect: 'r',
-    },
-    async run(c) {
-        const config = await loadConfig();
-        const profileNames = Object.keys(config.profiles).sort((a, b) => a.localeCompare(b));
-        if (profileNames.length === 0) {
-            throw new Error('No profiles found. Run `nnt profile add` first.');
-        }
-        const hasDirectEditOptions = Boolean(c.options.newName || c.options.botToken || c.options.chatId || c.options.reconnect);
-        const sourceName = await resolveProfileForEdit(c.args.profile, profileNames, hasDirectEditOptions);
-        const sourceProfile = config.profiles[sourceName];
-        if (!sourceProfile) {
-            throw new Error(`Profile "${sourceName}" not found.`);
-        }
-        const targetName = c.options.newName ?? sourceName;
-        if (targetName !== sourceName && config.profiles[targetName]) {
-            throw new Error(`Profile "${targetName}" already exists.`);
-        }
-        const botToken = c.options.botToken ?? sourceProfile.botToken;
-        let nextName = targetName;
-        let nextBotToken = botToken;
-        let chatId = c.options.chatId ?? sourceProfile.chatId;
-        let connectedUsername = null;
-        if (!hasDirectEditOptions && canPromptInteractively()) {
-            nextName = await askRequiredWithInitial('Profile name', sourceName);
-            if (nextName !== sourceName && config.profiles[nextName]) {
-                throw new Error(`Profile "${nextName}" already exists.`);
-            }
-            nextBotToken = await askRequiredWithInitial('Telegram bot token', sourceProfile.botToken);
-            const shouldReconnect = await askConfirm('Reconnect and detect chat_id from a new message?', false);
-            if (shouldReconnect) {
-                if (shouldRenderPretty(c.agent)) {
-                    process.stdout.write('\nSend any message to your bot in Telegram.\n');
-                    process.stdout.write('Waiting for message to detect chat_id (up to 120s)...\n');
-                }
-                const offset = await getLatestUpdateOffset(nextBotToken);
-                const connection = await waitForChatId(nextBotToken, offset, 120);
-                chatId = connection.chatId;
-                connectedUsername = connection.username;
-                if (shouldRenderPretty(c.agent)) {
-                    if (connection.username) {
-                        process.stdout.write(`Connected Telegram username: @${connection.username}\n`);
-                    }
-                    else {
-                        process.stdout.write('Connected Telegram user has no username set.\n');
-                    }
-                }
-            }
-            else {
-                chatId = await askRequiredWithInitial('Telegram chat_id', sourceProfile.chatId);
-            }
-        }
-        if (c.options.reconnect) {
-            if (shouldRenderPretty(c.agent)) {
-                process.stdout.write('\nSend any message to your bot in Telegram.\n');
-                process.stdout.write('Waiting for message to detect chat_id (up to 120s)...\n');
-            }
-            const offset = await getLatestUpdateOffset(nextBotToken);
-            const connection = await waitForChatId(nextBotToken, offset, 120);
-            chatId = connection.chatId;
-            connectedUsername = connection.username;
-            if (shouldRenderPretty(c.agent)) {
-                if (connection.username) {
-                    process.stdout.write(`Connected Telegram username: @${connection.username}\n`);
-                }
-                else {
-                    process.stdout.write('Connected Telegram user has no username set.\n');
-                }
-            }
-        }
-        const updatedProfile = {
-            ...sourceProfile,
-            name: nextName,
-            botToken: nextBotToken,
-            chatId,
-        };
-        if (nextName !== sourceName) {
-            delete config.profiles[sourceName];
-        }
-        config.profiles[nextName] = updatedProfile;
-        if (config.defaultProfile === sourceName) {
-            config.defaultProfile = nextName;
-        }
-        const hasChanges = nextName !== sourceName
-            || nextBotToken !== sourceProfile.botToken
-            || chatId !== sourceProfile.chatId;
-        if (!hasChanges) {
-            return {
-                updated: false,
-                profile: sourceName,
-                provider: sourceProfile.type,
-                defaultProfile: config.defaultProfile,
-                connectedUsername,
-            };
-        }
-        await saveConfig(config);
-        if (shouldRenderPretty(c.agent)) {
-            printKeyValueTable('Profile updated', [
-                { key: 'profile', value: nextName },
-                { key: 'provider', value: updatedProfile.type },
-                { key: 'chat_id', value: chatId },
-                { key: 'username', value: connectedUsername ? `@${connectedUsername}` : '(unchanged/none)' },
-                { key: 'default', value: config.defaultProfile ?? '(not set)' },
-            ]);
-        }
-        return {
-            updated: true,
-            previousProfile: sourceName,
-            profile: nextName,
-            provider: updatedProfile.type,
-            defaultProfile: config.defaultProfile,
-            connectedUsername,
-        };
-    },
-});
-const cli = Cli.create('nnt', {
-    description: 'Send Telegram notifications from terminal and agents',
-})
-    .command('send', {
-    description: 'Send a message via a saved profile',
-    args: z.object({
-        message: z.string().describe('Message text to send'),
-    }),
-    options: z.object({
-        profile: z.string().optional().describe('Profile name from config'),
-    }),
-    alias: {
-        profile: 'p',
-    },
-    async run(c) {
-        const config = await loadConfig();
-        const profileName = c.options.profile ?? config.defaultProfile;
-        if (!profileName) {
-            throw new Error('No default profile found. Run `nnt profile add` first.');
-        }
-        const profile = config.profiles[profileName];
-        if (!profile) {
-            throw new Error(`Profile "${profileName}" not found.`);
-        }
-        await sendTelegramMessage(profile.botToken, profile.chatId, c.args.message);
-        return {
-            sent: true,
-            profile: profileName,
-            provider: profile.type,
-        };
-    },
-})
-    .command(profileCli);
-function routeDefaultCommand(argv) {
-    if (argv.length === 0) {
-        return argv;
-    }
-    const topLevelCommands = new Set(['profile', 'send', 'skills', 'mcp']);
-    const bareGlobalFlags = new Set(['--help', '-h', '--version', '--llms', '--mcp', '--json', '--verbose']);
-    let index = 0;
-    while (index < argv.length) {
-        const token = argv[index];
-        if (token === '--format') {
-            index += 2;
-            continue;
-        }
-        if (bareGlobalFlags.has(token)) {
-            index += 1;
-            continue;
-        }
-        break;
-    }
-    if (index >= argv.length) {
-        return argv;
-    }
-    if (topLevelCommands.has(argv[index])) {
-        return argv;
-    }
-    return [...argv.slice(0, index), 'send', ...argv.slice(index)];
-}
-function normalizeFormatFlag(argv) {
-    const normalized = [];
-    for (const token of argv) {
-        if (token.startsWith('--format=')) {
-            normalized.push('--format', token.slice('--format='.length));
-            continue;
-        }
-        normalized.push(token);
-    }
-    return normalized;
-}
-function isStrictOutputRequested(argv) {
-    for (const token of argv) {
-        if (token === '--json' || token === '--verbose' || token === '--format') {
-            return true;
-        }
-    }
-    return false;
-}
-function isAgentEnvironment() {
-    return [
-        process.env.OPENCODE,
-        process.env.CLAUDECODE,
-        process.env.CURSOR_AGENT,
-        process.env.AIDER_SESSION,
-        process.env.NNT_AGENT_MODE,
-    ].some(Boolean);
-}
-function withAgentDefaultFormat(argv, strictOutputRequested) {
-    if (strictOutputRequested || !isAgentEnvironment()) {
-        return argv;
-    }
-    return ['--format', 'toon', ...argv];
-}
-function canPromptInteractively() {
-    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
-}
-async function resolveProfileForEdit(profileFromArgs, profileNames, hasDirectEditOptions) {
-    if (profileFromArgs) {
-        return profileFromArgs;
-    }
-    if (hasDirectEditOptions || !canPromptInteractively()) {
-        throw new Error('Profile name is required in non-interactive mode.');
-    }
-    return askSelect('Select profile to edit', profileNames.map(name => ({
-        value: name,
-        label: name,
-    })));
-}
-const normalizedArgv = normalizeFormatFlag(process.argv.slice(2));
-const strictOutputRequested = isStrictOutputRequested(normalizedArgv);
-const argvWithAgentDefaults = withAgentDefaultFormat(normalizedArgv, strictOutputRequested);
-function shouldRenderPretty(agent) {
-    return !agent && !strictOutputRequested && !isAgentEnvironment();
-}
-const routedArgv = routeDefaultCommand(argvWithAgentDefaults);
-await cli.serve(routedArgv);
-export default cli;

package/dist/config.js

@@ -1,49 +0,0 @@
-import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { mkdir, readFile, writeFile, chmod } from 'node:fs/promises';
-const DEFAULT_CONFIG = {
-    defaultProfile: null,
-    profiles: {},
-};
-export function getConfigDir() {
-    const dir = process.env.NNT_CONFIG_DIR;
-    if (dir && dir.trim() !== '') {
-        return resolve(dir);
-    }
-    return join(homedir(), '.nnt');
-}
-export function getConfigPath() {
-    return join(getConfigDir(), 'config');
-}
-export async function loadConfig() {
-    const path = getConfigPath();
-    try {
-        const raw = await readFile(path, 'utf8');
-        const parsed = JSON.parse(raw);
-        return {
-            defaultProfile: typeof parsed.defaultProfile === 'string' ? parsed.defaultProfile : null,
-            profiles: parsed.profiles ?? {},
-        };
-    }
-    catch (error) {
-        if (isNodeError(error) && error.code === 'ENOENT') {
-            return { ...DEFAULT_CONFIG };
-        }
-        throw error;
-    }
-}
-export async function saveConfig(config) {
-    const dir = getConfigDir();
-    const path = getConfigPath();
-    await mkdir(dir, { recursive: true });
-    await writeFile(path, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
-    try {
-        await chmod(path, 0o600);
-    }
-    catch {
-        // Best effort only.
-    }
-}
-function isNodeError(error) {
-    return typeof error === 'object' && error !== null && 'code' in error;
-}

package/dist/display.js

@@ -1,24 +0,0 @@
-import Table from 'cli-table3';
-export function printProfilesTable(rows) {
-    if (rows.length === 0) {
-        process.stdout.write('No profiles configured. Run `nnt profile add`.\n');
-        return;
-    }
-    const table = new Table({
-        head: ['Profile', 'Provider', 'Default'],
-    });
-    for (const row of rows) {
-        table.push([row.name, row.provider, row.isDefault ? 'yes' : '']);
-    }
-    process.stdout.write(`${table.toString()}\n`);
-}
-export function printKeyValueTable(title, rows) {
-    process.stdout.write(`${title}\n`);
-    const table = new Table({
-        head: ['Field', 'Value'],
-    });
-    for (const row of rows) {
-        table.push([row.key, row.value]);
-    }
-    process.stdout.write(`${table.toString()}\n`);
-}

package/dist/prompt.js

@@ -1,47 +0,0 @@
-import { cancel, confirm, isCancel, select, text } from '@clack/prompts';
-export async function askRequired(question) {
-    return askRequiredWithInitial(question);
-}
-export async function askRequiredWithInitial(question, initialValue) {
-    const message = normalizeQuestion(question);
-    const value = await text({
-        message,
-        initialValue,
-        validate(input) {
-            if (!input || input.trim() === '') {
-                return 'Value cannot be empty';
-            }
-            return undefined;
-        },
-    });
-    if (isCancel(value)) {
-        cancel('Operation cancelled.');
-        process.exit(1);
-    }
-    return value.trim();
-}
-export async function askConfirm(question, initialValue = false) {
-    const value = await confirm({
-        message: normalizeQuestion(question),
-        initialValue,
-    });
-    if (isCancel(value)) {
-        cancel('Operation cancelled.');
-        process.exit(1);
-    }
-    return value;
-}
-export async function askSelect(question, options) {
-    const value = await select({
-        message: normalizeQuestion(question),
-        options,
-    });
-    if (isCancel(value)) {
-        cancel('Operation cancelled.');
-        process.exit(1);
-    }
-    return value;
-}
-function normalizeQuestion(question) {
-    return question.trim().replace(/:\s*$/, '');
-}

package/dist/telegram.js

@@ -1,57 +0,0 @@
-async function telegramRequest(botToken, method, payload) {
-    const response = await fetch(`https://api.telegram.org/bot${botToken}/${method}`, {
-        method: 'POST',
-        headers: {
-            'content-type': 'application/json',
-        },
-        body: JSON.stringify(payload),
-    });
-    if (!response.ok) {
-        throw new Error(`Telegram API HTTP ${response.status}`);
-    }
-    const json = await response.json();
-    if (!json.ok) {
-        throw new Error(json.description);
-    }
-    return json.result;
-}
-export async function getLatestUpdateOffset(botToken) {
-    const updates = await telegramRequest(botToken, 'getUpdates', {
-        timeout: 0,
-        allowed_updates: ['message'],
-    });
-    if (updates.length === 0) {
-        return 0;
-    }
-    const maxUpdateId = updates.reduce((acc, item) => Math.max(acc, item.update_id), 0);
-    return maxUpdateId + 1;
-}
-export async function waitForChatId(botToken, offset, timeoutSeconds = 120) {
-    const startedAt = Date.now();
-    let currentOffset = offset;
-    while ((Date.now() - startedAt) / 1000 < timeoutSeconds) {
-        const remainingSeconds = timeoutSeconds - Math.floor((Date.now() - startedAt) / 1000);
-        const pollTimeout = Math.max(1, Math.min(25, remainingSeconds));
-        const updates = await telegramRequest(botToken, 'getUpdates', {
-            offset: currentOffset,
-            timeout: pollTimeout,
-            allowed_updates: ['message'],
-        });
-        for (const update of updates) {
-            currentOffset = Math.max(currentOffset, update.update_id + 1);
-            if (update.message?.chat?.id !== undefined) {
-                return {
-                    chatId: String(update.message.chat.id),
-                    username: update.message.from?.username ?? update.message.chat.username ?? null,
-                };
-            }
-        }
-    }
-    throw new Error('Timed out waiting for Telegram message. Send a message to your bot and try again.');
-}
-export async function sendTelegramMessage(botToken, chatId, text) {
-    await telegramRequest(botToken, 'sendMessage', {
-        chat_id: chatId,
-        text,
-    });
-}