nonotify 0.1.14 → 0.2.0

package/dist/telegram.js

@@ -1,16 +1,31 @@
-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),
-    });
+const allowedUpdateTypes = ["message", "callback_query"];
+const updateStreams = new Map();
+const shortPollIntervalMs = 1_000;
+async function telegramRequest(botToken, method, payload, signal) {
+    let response;
+    try {
+        response = await fetch(`https://api.telegram.org/bot${botToken}/${method}`, {
+            method: "POST",
+            signal,
+            headers: {
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(payload),
+        });
+    }
+    catch (error) {
+        throw new Error(formatTelegramFetchError(method, error));
+    }
     if (!response.ok) {
-        throw new Error(`Telegram API HTTP ${response.status}`);
+        throw new Error(`Telegram ${method} failed with HTTP ${response.status}.`);
     }
     const json = (await response.json());
     if (!json.ok) {
+        if (method === "getUpdates" &&
+            /webhook/i.test(json.description) &&
+            /active|set/i.test(json.description)) {
+            throw new Error("This Telegram bot has an active webhook. `nnt ask` requires getUpdates, so disable the webhook or use a separate bot token for nonotify.");
+        }
         throw new Error(json.description);
     }
     return json.result;
@@ -18,7 +33,7 @@ async function telegramRequest(botToken, method, payload) {
 export async function getLatestUpdateOffset(botToken) {
     const updates = await telegramRequest(botToken, "getUpdates", {
         timeout: 0,
-        allowed_updates: ["message"],
+        allowed_updates: allowedUpdateTypes,
     });
     if (updates.length === 0) {
         return 0;
@@ -26,30 +41,30 @@ export async function getLatestUpdateOffset(botToken) {
     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,
-                };
+export async function waitForChatId(botToken, offset, timeoutSeconds = 120, signal) {
+    const stream = getTelegramUpdateStream(botToken, offset);
+    try {
+        return await stream.waitFor((update) => {
+            if (update.message?.chat?.id === undefined) {
+                return undefined;
             }
+            return {
+                chatId: String(update.message.chat.id),
+                username: update.message.from?.username ??
+                    update.message.chat.username ??
+                    null,
+            };
+        }, {
+            timeoutMs: timeoutSeconds * 1000,
+            signal,
+        });
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === "Timed out waiting") {
+            throw new Error("Timed out waiting for Telegram message. Send a message to your bot and try again.");
         }
+        throw error;
     }
-    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", {
@@ -57,3 +72,250 @@ export async function sendTelegramMessage(botToken, chatId, text) {
         text,
     });
 }
+export async function sendTelegramChoiceMessage(botToken, chatId, text, options) {
+    const message = await telegramRequest(botToken, "sendMessage", {
+        chat_id: chatId,
+        text,
+        reply_markup: {
+            inline_keyboard: options.map((option) => [
+                {
+                    text: option.label,
+                    callback_data: option.callbackData,
+                },
+            ]),
+        },
+    });
+    return {
+        messageId: message.message_id,
+    };
+}
+export async function waitForTelegramCallback(botToken, input) {
+    const stream = getTelegramUpdateStream(botToken, input.offset);
+    const allowedCallbackData = new Set(input.callbackData);
+    return stream.waitFor((update) => {
+        const callback = update.callback_query;
+        if (!callback?.message ||
+            String(callback.message.chat?.id) !== input.chatId ||
+            callback.message.message_id !== input.messageId ||
+            typeof callback.data !== "string" ||
+            !allowedCallbackData.has(callback.data)) {
+            return undefined;
+        }
+        return {
+            callbackQueryId: callback.id,
+            data: callback.data,
+        };
+    }, {
+        timeoutMs: input.timeoutMs,
+        signal: input.signal,
+    });
+}
+export async function answerTelegramCallbackQuery(botToken, callbackQueryId) {
+    await telegramRequest(botToken, "answerCallbackQuery", {
+        callback_query_id: callbackQueryId,
+    });
+}
+export async function clearTelegramInlineKeyboard(botToken, chatId, messageId) {
+    try {
+        await telegramRequest(botToken, "editMessageReplyMarkup", {
+            chat_id: chatId,
+            message_id: messageId,
+            reply_markup: {
+                inline_keyboard: [],
+            },
+        });
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            /message is not modified/i.test(error.message)) {
+            return;
+        }
+        throw error;
+    }
+}
+export async function markTelegramSelectedOption(botToken, chatId, messageId, options, selectedCallbackData) {
+    try {
+        await telegramRequest(botToken, "editMessageReplyMarkup", {
+            chat_id: chatId,
+            message_id: messageId,
+            reply_markup: {
+                inline_keyboard: options.map((option) => [
+                    {
+                        text: option.callbackData === selectedCallbackData
+                            ? `✅ ${option.label}`
+                            : option.label,
+                        callback_data: option.callbackData,
+                    },
+                ]),
+            },
+        });
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            /message is not modified/i.test(error.message)) {
+            return;
+        }
+        throw error;
+    }
+}
+function getTelegramUpdateStream(botToken, offset = 0) {
+    const existing = updateStreams.get(botToken);
+    if (existing) {
+        existing.setMinimumOffset(offset);
+        return existing;
+    }
+    const stream = new TelegramUpdateStream(botToken, offset);
+    updateStreams.set(botToken, stream);
+    return stream;
+}
+class TelegramUpdateStream {
+    botToken;
+    currentOffset;
+    waiters = new Set();
+    pollPromise = null;
+    pollAbortController = null;
+    constructor(botToken, initialOffset) {
+        this.botToken = botToken;
+        this.currentOffset = initialOffset;
+    }
+    setMinimumOffset(offset) {
+        this.currentOffset = Math.max(this.currentOffset, offset);
+    }
+    async waitFor(match, options = {}) {
+        if (options.signal?.aborted) {
+            throw options.signal.reason ?? new DOMException("Aborted", "AbortError");
+        }
+        return new Promise((resolve, reject) => {
+            const abortListener = () => {
+                unregister();
+                reject(options.signal?.reason ?? new DOMException("Aborted", "AbortError"));
+            };
+            const timeout = typeof options.timeoutMs === "number"
+                ? setTimeout(() => {
+                    unregister();
+                    reject(new Error("Timed out waiting"));
+                }, options.timeoutMs)
+                : null;
+            const waiter = {
+                match,
+                resolve: (value) => {
+                    unregister();
+                    resolve(value);
+                },
+                reject: (error) => {
+                    unregister();
+                    reject(error);
+                },
+            };
+            const unregister = () => {
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+                options.signal?.removeEventListener("abort", abortListener);
+                this.waiters.delete(waiter);
+                if (this.waiters.size === 0) {
+                    this.pollAbortController?.abort();
+                }
+            };
+            this.waiters.add(waiter);
+            options.signal?.addEventListener("abort", abortListener, { once: true });
+            this.ensurePolling();
+        });
+    }
+    ensurePolling() {
+        if (this.pollPromise) {
+            return;
+        }
+        this.pollPromise = this.pollLoop().finally(() => {
+            this.pollPromise = null;
+            if (this.waiters.size === 0) {
+                updateStreams.delete(this.botToken);
+            }
+        });
+    }
+    async pollLoop() {
+        while (this.waiters.size > 0) {
+            this.pollAbortController = new AbortController();
+            try {
+                const updates = await telegramRequest(this.botToken, "getUpdates", {
+                    offset: this.currentOffset,
+                    timeout: 0,
+                    allowed_updates: allowedUpdateTypes,
+                }, this.pollAbortController.signal);
+                for (const update of updates) {
+                    this.currentOffset = Math.max(this.currentOffset, update.update_id + 1);
+                    this.dispatch(update);
+                }
+                if (updates.length === 0 && this.waiters.size > 0) {
+                    await delay(shortPollIntervalMs, this.pollAbortController.signal);
+                }
+            }
+            catch (error) {
+                if (isAbortError(error) && this.waiters.size === 0) {
+                    return;
+                }
+                this.rejectAll(error);
+                return;
+            }
+            finally {
+                this.pollAbortController = null;
+            }
+        }
+    }
+    dispatch(update) {
+        for (const waiter of Array.from(this.waiters)) {
+            try {
+                const result = waiter.match(update);
+                if (result !== undefined) {
+                    waiter.resolve(result);
+                }
+            }
+            catch (error) {
+                waiter.reject(error);
+            }
+        }
+    }
+    rejectAll(error) {
+        for (const waiter of Array.from(this.waiters)) {
+            waiter.reject(error);
+        }
+    }
+}
+function isAbortError(error) {
+    return error instanceof DOMException
+        ? error.name === "AbortError"
+        : error instanceof Error && error.name === "AbortError";
+}
+async function delay(ms, signal) {
+    if (signal?.aborted) {
+        throw signal.reason ?? new DOMException("Aborted", "AbortError");
+    }
+    await new Promise((resolve, reject) => {
+        const onAbort = () => {
+            clearTimeout(timeout);
+            signal?.removeEventListener("abort", onAbort);
+            const abortReason = signal?.reason ?? new DOMException("Aborted", "AbortError");
+            reject(abortReason);
+        };
+        const timeout = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function formatTelegramFetchError(method, error) {
+    if (!(error instanceof Error)) {
+        return `Telegram ${method} request failed: ${String(error)}`;
+    }
+    const causeMessage = typeof error.cause === "object" &&
+        error.cause !== null &&
+        "message" in error.cause &&
+        typeof error.cause.message === "string"
+        ? error.cause.message
+        : null;
+    if (causeMessage) {
+        return `Telegram ${method} request failed: ${error.message} (${causeMessage})`;
+    }
+    return `Telegram ${method} request failed: ${error.message}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nonotify",
-  "version": "0.1.14",
+  "version": "0.2.0",
   "description": "nnt CLI for Telegram notifications",
   "type": "module",
   "main": "./dist/index.js",
@@ -35,13 +35,13 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@clack/prompts": "^1.0.1",
+    "@clack/prompts": "^1.1.0",
     "cli-table3": "^0.6.5",
-    "incur": "^0.1.8"
+    "incur": "^0.3.13"
   },
   "devDependencies": {
-    "@types/node": "^24.6.2",
-    "tsx": "^4.20.6",
-    "typescript": "^5.9.3"
+    "@types/node": "^25.5.0",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.2"
   }
 }

package/src/cli.ts

@@ -14,7 +14,12 @@ import {
   sendTelegramMessage,
   waitForChatId,
 } from "./telegram.js";
-import { Notifier } from "./notifier.js";
+import {
+  AskAbortedError,
+  AskTimeoutError,
+  Notifier,
+  NotifierError,
+} from "./notifier.js";
 
 const profileCli = Cli.create("profile", {
   description: "Manage notification profiles",
@@ -453,12 +458,20 @@ const cli = Cli.create("nnt", {
   })
   .command(profileCli);
 
+type ParsedAskArgs = {
+  message: string;
+  options: string[];
+  profile?: string;
+  timeoutMs?: number;
+  helpRequested: boolean;
+};
+
 function routeDefaultCommand(argv: string[]): string[] {
   if (argv.length === 0) {
     return argv;
   }
 
-  const topLevelCommands = new Set(["profile", "send", "skills", "mcp"]);
+  const topLevelCommands = new Set(["ask", "profile", "send", "skills", "mcp"]);
   const bareGlobalFlags = new Set([
     "--help",
     "-h",
@@ -512,6 +525,90 @@ function normalizeFormatFlag(argv: string[]): string[] {
   return normalized;
 }
 
+function getCommandIndex(argv: string[]): number {
+  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;
+  }
+
+  return index;
+}
+
+async function serveAskCommandIfRequested(argv: string[]): Promise<boolean> {
+  const commandIndex = getCommandIndex(argv);
+
+  if (commandIndex >= argv.length || argv[commandIndex] !== "ask") {
+    return false;
+  }
+
+  try {
+    const parsed = parseAskArgs(argv.slice(commandIndex + 1));
+
+    if (parsed.helpRequested) {
+      process.stderr.write(getAskUsage());
+      return true;
+    }
+
+    const notifier = new Notifier();
+    const abortController = new AbortController();
+    let exitCode = 0;
+    const onAbortSignal = () => abortController.abort();
+
+    process.once("SIGINT", onAbortSignal);
+    process.once("SIGTERM", onAbortSignal);
+
+    try {
+      const result = await notifier.ask({
+        message: parsed.message,
+        options: parsed.options,
+        profile: parsed.profile,
+        timeoutMs: parsed.timeoutMs,
+        signal: abortController.signal,
+      });
+
+      process.stdout.write(`${result.selected}\n`);
+    } catch (error) {
+      exitCode = renderAskError(error);
+    } finally {
+      process.removeListener("SIGINT", onAbortSignal);
+      process.removeListener("SIGTERM", onAbortSignal);
+    }
+
+    if (exitCode !== 0) {
+      process.exitCode = exitCode;
+    }
+
+    return true;
+  } catch (error) {
+    process.stderr.write(`${formatAskError(error)}\n`);
+    process.exitCode = 1;
+    return true;
+  }
+}
+
 function isStrictOutputRequested(argv: string[]): boolean {
   for (const token of argv) {
     if (token === "--json" || token === "--verbose" || token === "--format") {
@@ -580,7 +677,130 @@ function shouldRenderPretty(agent: boolean): boolean {
   return !agent && !strictOutputRequested && !isAgentEnvironment();
 }
 
-const routedArgv = routeDefaultCommand(argvWithAgentDefaults);
-await cli.serve(routedArgv);
+if (!(await serveAskCommandIfRequested(normalizedArgv))) {
+  const routedArgv = routeDefaultCommand(argvWithAgentDefaults);
+  await cli.serve(routedArgv);
+}
 
 export default cli;
+
+function parseAskArgs(argv: string[]): ParsedAskArgs {
+  let profile: string | undefined;
+  let timeoutMs: number | undefined;
+  let helpRequested = false;
+  const positionals: string[] = [];
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+
+    if (token === "--help" || token === "-h") {
+      helpRequested = true;
+      continue;
+    }
+
+    if (token === "--profile" || token === "-p") {
+      const value = argv[index + 1];
+
+      if (!value) {
+        throw new Error("Missing value for --profile.");
+      }
+
+      profile = value;
+      index += 1;
+      continue;
+    }
+
+    if (token.startsWith("--profile=")) {
+      profile = token.slice("--profile=".length);
+      continue;
+    }
+
+    if (token === "--timeout" || token === "-t") {
+      const value = argv[index + 1];
+
+      if (!value) {
+        throw new Error("Missing value for --timeout.");
+      }
+
+      timeoutMs = parseTimeoutFlag(value);
+      index += 1;
+      continue;
+    }
+
+    if (token.startsWith("--timeout=")) {
+      timeoutMs = parseTimeoutFlag(token.slice("--timeout=".length));
+      continue;
+    }
+
+    if (token.startsWith("-")) {
+      throw new Error(`Unknown option: ${token}`);
+    }
+
+    positionals.push(token);
+  }
+
+  if (helpRequested) {
+    return {
+      message: "",
+      options: [],
+      profile,
+      timeoutMs,
+      helpRequested,
+    };
+  }
+
+  if (positionals.length < 2) {
+    throw new Error(
+      "Ask requires a message and at least one option. See `nnt ask --help`."
+    );
+  }
+
+  return {
+    message: positionals[0],
+    options: positionals.slice(1),
+    profile,
+    timeoutMs,
+    helpRequested,
+  };
+}
+
+function parseTimeoutFlag(value: string): number {
+  const seconds = Number(value);
+
+  if (!Number.isFinite(seconds) || seconds < 0) {
+    throw new Error("--timeout must be a non-negative number of seconds.");
+  }
+
+  return Math.round(seconds * 1000);
+}
+
+function getAskUsage(): string {
+  return [
+    "Usage: nnt ask [--profile <name>] [--timeout <seconds>] <message> <option1> [option2 ... option10]",
+    "",
+    "Prints only the selected option to stdout.",
+  ].join("\n");
+}
+
+function renderAskError(error: unknown): number {
+  if (error instanceof AskTimeoutError) {
+    process.stderr.write(`${error.message}\n`);
+    return 1;
+  }
+
+  if (error instanceof AskAbortedError) {
+    process.stderr.write("Cancelled.\n");
+    return 130;
+  }
+
+  process.stderr.write(`${formatAskError(error)}\n`);
+  return 1;
+}
+
+function formatAskError(error: unknown): string {
+  if (error instanceof NotifierError || error instanceof Error) {
+    return error.message;
+  }
+
+  return String(error);
+}

package/src/index.ts

@@ -1,4 +1,6 @@
 export {
+  AskAbortedError,
+  AskTimeoutError,
   EnvConfigLoader,
   NoProfilesConfiguredError,
   Notifier,
@@ -6,6 +8,8 @@ export {
   ProfileNotFoundError,
 } from "./notifier.js";
 export type {
+  AskInput,
+  AskResult,
   NotifierConfig,
   NotifierConfigLoader,
   NotifierProfile,