nonotify 0.1.0

package/src/display.ts

@@ -0,0 +1,38 @@
+import Table from 'cli-table3'
+
+type ProfileRow = {
+  name: string
+  provider: string
+  isDefault: boolean
+}
+
+export function printProfilesTable(rows: ProfileRow[]): void {
+  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: string, rows: Array<{ key: string, value: string }>): void {
+  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/src/prompt.ts

@@ -0,0 +1,67 @@
+import { cancel, confirm, isCancel, select, text } from '@clack/prompts'
+
+export async function askRequired(question: string): Promise<string> {
+  return askRequiredWithInitial(question)
+}
+
+export async function askRequiredWithInitial(question: string, initialValue?: string): Promise<string> {
+  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: string, initialValue = false): Promise<boolean> {
+  const value = await confirm({
+    message: normalizeQuestion(question),
+    initialValue,
+  })
+
+  if (isCancel(value)) {
+    cancel('Operation cancelled.')
+    process.exit(1)
+  }
+
+  return value
+}
+
+type SelectOption = {
+  value: string
+  label: string
+  hint?: string
+  disabled?: boolean
+}
+
+export async function askSelect(question: string, options: SelectOption[]): Promise<string> {
+  const value = await select<string>({
+    message: normalizeQuestion(question),
+    options,
+  })
+
+  if (isCancel(value)) {
+    cancel('Operation cancelled.')
+    process.exit(1)
+  }
+
+  return value
+}
+
+function normalizeQuestion(question: string): string {
+  return question.trim().replace(/:\s*$/, '')
+}

package/src/telegram.ts

@@ -0,0 +1,109 @@
+type TelegramApiResponse<T> =
+  | {
+    ok: true
+    result: T
+  }
+  | {
+    ok: false
+    error_code: number
+    description: string
+  }
+
+type TelegramUpdate = {
+  update_id: number
+  message?: {
+    from?: {
+      username?: string
+    }
+    chat?: {
+      id: number
+      username?: string
+    }
+    text?: string
+  }
+}
+
+export type TelegramConnection = {
+  chatId: string
+  username: string | null
+}
+
+async function telegramRequest<T>(
+  botToken: string,
+  method: string,
+  payload: Record<string, unknown>,
+): Promise<T> {
+  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() as TelegramApiResponse<T>
+
+  if (!json.ok) {
+    throw new Error(json.description)
+  }
+
+  return json.result
+}
+
+export async function getLatestUpdateOffset(botToken: string): Promise<number> {
+  const updates = await telegramRequest<TelegramUpdate[]>(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: string,
+  offset: number,
+  timeoutSeconds = 120,
+): Promise<TelegramConnection> {
+  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<TelegramUpdate[]>(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: string, chatId: string, text: string): Promise<void> {
+  await telegramRequest(botToken, 'sendMessage', {
+    chat_id: chatId,
+    text,
+  })
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": [
+    "src/**/*.ts"
+  ]
+}