nonotify 0.1.15 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # nonotify
 
+## 0.2.0
+
+### Minor Changes
+
+- 5384093: Add interactive `nnt ask` Telegram prompts, expose `Notifier.ask()`, and let the OpenCode plugin answer pending permissions and questions through Telegram buttons.
+
 ## 0.1.15
 
 ### Patch Changes

package/dist/cli.js

@@ -4,7 +4,7 @@ import { askConfirm, askRequired, askRequiredWithInitial, askSelect, } from "./p
 import { getConfigPath, loadConfig, saveConfig } from "./config.js";
 import { printKeyValueTable, printProfilesTable } from "./display.js";
 import { getLatestUpdateOffset, 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",
 });
@@ -348,7 +348,7 @@ function routeDefaultCommand(argv) {
     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",
@@ -390,6 +390,76 @@ function normalizeFormatFlag(argv) {
     }
     return normalized;
 }
+function getCommandIndex(argv) {
+    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) {
+    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) {
     for (const token of argv) {
         if (token === "--json" || token === "--verbose" || token === "--format") {
@@ -434,6 +504,102 @@ const argvWithAgentDefaults = withAgentDefaultFormat(normalizedArgv, strictOutpu
 function shouldRenderPretty(agent) {
     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) {
+    let profile;
+    let timeoutMs;
+    let helpRequested = false;
+    const positionals = [];
+    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) {
+    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() {
+    return [
+        "Usage: nnt ask [--profile <name>] [--timeout <seconds>] <message> <option1> [option2 ... option10]",
+        "",
+        "Prints only the selected option to stdout.",
+    ].join("\n");
+}
+function renderAskError(error) {
+    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) {
+    if (error instanceof NotifierError || error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { EnvConfigLoader, NoProfilesConfiguredError, Notifier, NotifierError, ProfileNotFoundError, } from "./notifier.js";
-export type { NotifierConfig, NotifierConfigLoader, NotifierProfile, NotifierProfileInput, SendInput, SendResult, } from "./notifier.js";
+export { AskAbortedError, AskTimeoutError, EnvConfigLoader, NoProfilesConfiguredError, Notifier, NotifierError, ProfileNotFoundError, } from "./notifier.js";
+export type { AskInput, AskResult, NotifierConfig, NotifierConfigLoader, NotifierProfile, NotifierProfileInput, SendInput, SendResult, } from "./notifier.js";

package/dist/index.js

@@ -1 +1 @@
-export { EnvConfigLoader, NoProfilesConfiguredError, Notifier, NotifierError, ProfileNotFoundError, } from "./notifier.js";
+export { AskAbortedError, AskTimeoutError, EnvConfigLoader, NoProfilesConfiguredError, Notifier, NotifierError, ProfileNotFoundError, } from "./notifier.js";

package/dist/notifier.d.ts

@@ -26,6 +26,18 @@ export type SendResult = {
     profile: string;
     provider: "telegram";
 };
+export type AskInput = {
+    message: string;
+    options: readonly string[];
+    profile?: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+};
+export type AskResult = {
+    selected: string;
+    profile: string;
+    provider: "telegram";
+};
 export declare class NotifierError extends Error {
     constructor(message: string);
 }
@@ -36,6 +48,12 @@ export declare class ProfileNotFoundError extends NotifierError {
 export declare class NoProfilesConfiguredError extends NotifierError {
     constructor();
 }
+export declare class AskTimeoutError extends NotifierError {
+    constructor();
+}
+export declare class AskAbortedError extends NotifierError {
+    constructor();
+}
 export declare class EnvConfigLoader implements NotifierConfigLoader {
     load(): NotifierConfig;
 }
@@ -45,5 +63,6 @@ export declare class Notifier {
     private readonly profilesByName;
     constructor(source?: NotifierConfig | NotifierConfigLoader);
     send(input: SendInput): Promise<SendResult>;
+    ask(input: AskInput): Promise<AskResult>;
     private resolveProfile;
 }

package/dist/notifier.js

@@ -1,6 +1,7 @@
 import { readFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
 import { getConfigPath, getLegacyConfigPath } from "./config.js";
-import { sendTelegramMessage } from "./telegram.js";
+import { answerTelegramCallbackQuery, clearTelegramInlineKeyboard, getLatestUpdateOffset, markTelegramSelectedOption, sendTelegramChoiceMessage, sendTelegramMessage, waitForTelegramCallback, } from "./telegram.js";
 export class NotifierError extends Error {
     constructor(message) {
         super(message);
@@ -21,6 +22,18 @@ export class NoProfilesConfiguredError extends NotifierError {
         this.name = "NoProfilesConfiguredError";
     }
 }
+export class AskTimeoutError extends NotifierError {
+    constructor() {
+        super("Timed out waiting for Telegram answer.");
+        this.name = "AskTimeoutError";
+    }
+}
+export class AskAbortedError extends NotifierError {
+    constructor() {
+        super("Telegram answer wait was aborted.");
+        this.name = "AskAbortedError";
+    }
+}
 export class EnvConfigLoader {
     load() {
         const configPaths = Array.from(new Set([getConfigPath(), getLegacyConfigPath()]));
@@ -71,6 +84,81 @@ export class Notifier {
             provider: selectedProfile.type,
         };
     }
+    async ask(input) {
+        const message = input.message.trim();
+        if (message === "") {
+            throw new NotifierError("Message cannot be empty.");
+        }
+        if (!Array.isArray(input.options)) {
+            throw new NotifierError("Options must be an array.");
+        }
+        if (input.options.length < 1 || input.options.length > 10) {
+            throw new NotifierError("Options must contain between 1 and 10 items.");
+        }
+        const options = input.options.map((option, index) => {
+            if (typeof option !== "string" || option.trim() === "") {
+                throw new NotifierError(`Invalid option at index ${index}: expected non-empty string.`);
+            }
+            return option.trim();
+        });
+        if (input.timeoutMs !== undefined &&
+            (!Number.isFinite(input.timeoutMs) || input.timeoutMs < 0)) {
+            throw new NotifierError("timeoutMs must be a non-negative number.");
+        }
+        const selectedProfile = this.resolveProfile(input.profile);
+        const offset = await getLatestUpdateOffset(selectedProfile.botToken);
+        const requestId = randomUUID().replaceAll("-", "");
+        const callbackOptions = options.map((option, index) => ({
+            label: option,
+            callbackData: `nnt:${requestId}:${index}`,
+        }));
+        const sentMessage = await sendTelegramChoiceMessage(selectedProfile.botToken, selectedProfile.chatId, message, callbackOptions);
+        try {
+            const callback = await waitForTelegramCallback(selectedProfile.botToken, {
+                chatId: selectedProfile.chatId,
+                messageId: sentMessage.messageId,
+                callbackData: callbackOptions.map((option) => option.callbackData),
+                offset,
+                timeoutMs: input.timeoutMs,
+                signal: input.signal,
+            });
+            const selectedIndex = callbackOptions.findIndex((option) => option.callbackData === callback.data);
+            if (selectedIndex === -1) {
+                throw new NotifierError("Received an unknown Telegram answer.");
+            }
+            await answerTelegramCallbackQuery(selectedProfile.botToken, callback.callbackQueryId);
+            try {
+                await markTelegramSelectedOption(selectedProfile.botToken, selectedProfile.chatId, sentMessage.messageId, callbackOptions, callback.data);
+            }
+            catch {
+                // Keep the selected answer even if the visual update fails.
+            }
+            return {
+                selected: options[selectedIndex],
+                profile: selectedProfile.name,
+                provider: selectedProfile.type,
+            };
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === "Timed out waiting") {
+                throw new AskTimeoutError();
+            }
+            if (isAbortError(error)) {
+                throw new AskAbortedError();
+            }
+            throw error;
+        }
+        finally {
+            if (input.signal?.aborted) {
+                try {
+                    await clearTelegramInlineKeyboard(selectedProfile.botToken, selectedProfile.chatId, sentMessage.messageId);
+                }
+                catch {
+                    // Do not mask the original ask result or failure if cleanup fails.
+                }
+            }
+        }
+    }
     resolveProfile(profileName) {
         if (profileName) {
             const profile = this.profilesByName.get(profileName);
@@ -169,3 +257,8 @@ function isConfigLoader(value) {
 function isNodeError(error) {
     return typeof error === "object" && error !== null && "code" in error;
 }
+function isAbortError(error) {
+    return error instanceof DOMException
+        ? error.name === "AbortError"
+        : error instanceof Error && error.name === "AbortError";
+}

package/dist/telegram.d.ts

@@ -2,6 +2,29 @@ export type TelegramConnection = {
     chatId: string;
     username: string | null;
 };
+export type TelegramInlineOption = {
+    label: string;
+    callbackData: string;
+};
+export type TelegramChoiceMessage = {
+    messageId: number;
+};
+export type TelegramCallbackSelection = {
+    callbackQueryId: string;
+    data: string;
+};
 export declare function getLatestUpdateOffset(botToken: string): Promise<number>;
-export declare function waitForChatId(botToken: string, offset: number, timeoutSeconds?: number): Promise<TelegramConnection>;
+export declare function waitForChatId(botToken: string, offset: number, timeoutSeconds?: number, signal?: AbortSignal): Promise<TelegramConnection>;
 export declare function sendTelegramMessage(botToken: string, chatId: string, text: string): Promise<void>;
+export declare function sendTelegramChoiceMessage(botToken: string, chatId: string, text: string, options: readonly TelegramInlineOption[]): Promise<TelegramChoiceMessage>;
+export declare function waitForTelegramCallback(botToken: string, input: {
+    chatId: string;
+    messageId: number;
+    callbackData: readonly string[];
+    offset?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}): Promise<TelegramCallbackSelection>;
+export declare function answerTelegramCallbackQuery(botToken: string, callbackQueryId: string): Promise<void>;
+export declare function clearTelegramInlineKeyboard(botToken: string, chatId: string, messageId: number): Promise<void>;
+export declare function markTelegramSelectedOption(botToken: string, chatId: string, messageId: number, options: readonly TelegramInlineOption[], selectedCallbackData: string): Promise<void>;