telegram-ask 0.1.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,143 @@
+# telegram-ask
+
+Small local service that asks you a question on Telegram and hands the answer back to the caller. A script POSTs a question with button options to a local HTTP API; the bot sends it to you with inline buttons, and the request returns when you tap one or the timeout fires.
+
+Single owner, one Telegram user. Needs Node 24+ for `npx` and the systemd target; the container targets bring their own Node.
+
+## Install
+
+```
+npx telegram-ask init
+```
+
+Create a bot with @BotFather first and have the token ready. `init`:
+
+1. Detects which targets work here (Podman Quadlet, Docker Compose, systemd) and asks where the bot should run. The first usable one in that order is the default. Or pass it: `init quadlet`, `init compose`, `init systemd`.
+2. Asks for the bot token (input hidden) and checks it with Telegram. Port is 8787; use `--port N` to change it. It refuses a port that's already in use.
+3. Installs and starts the service, then waits for pairing.
+
+If it finds an existing install it offers to replace it, reusing the saved token and owner (no re-pairing). If there's no install but a token was kept by `uninstall`, it reuses that (and the owner) too. If `init` fails partway, run it again; the old install record and saved token are kept until the new install succeeds.
+
+## Pairing
+
+The first time (and after `reset-owner`), the bot only answers whoever proves they own it. `init` prints a code like `ABCD-EFGH` and a link. Either send `/start ABCD-EFGH` to your bot, or open `https://t.me/<bot>?start=ABCDEFGH`. Case and the dash don't matter. After 5 wrong codes from one Telegram user that user is blocked until the service restarts.
+
+If you lose the code: `telegram-ask status` prints it again while unpaired.
+
+To move to another Telegram account:
+
+```
+telegram-ask reset-owner
+```
+
+It asks first, clears the owner, restarts the service and waits for a new pairing.
+
+## Targets
+
+All targets keep their files under `~/.config/telegram-ask/` (or `$XDG_CONFIG_HOME/telegram-ask/`). `install.json` there records which target is installed, its port and version. It's what `status`, `reset-owner` and `uninstall` read.
+
+### Podman Quadlet
+
+Needs Podman 4.4 or newer and a systemd user session. Written:
+
+- `~/.config/telegram-ask/quadlet/` with a `Dockerfile`, `.env` (token, port, owner) and a `.dockerignore` that keeps `.env` out of the image build
+- `~/.config/containers/systemd/telegram-ask.container`
+- image `localhost/telegram-ask:<version>`, volume `telegram-ask-data` (holds the pairing state)
+
+Runs as a user service named `telegram-ask`. `init` enables linger (`loginctl enable-linger`) if needed so it survives logout; it tells you if that needs a password. Logs:
+
+```
+journalctl --user -u telegram-ask -f
+```
+
+### Docker Compose
+
+Needs Docker with the compose v2 plugin, and your user in the `docker` group (otherwise `init` reports it can't talk to docker and skips this target). Written:
+
+- `~/.config/telegram-ask/compose/` with `Dockerfile`, `compose.yaml`, `.env` and `.dockerignore`
+- a named volume `data` in the `telegram-ask` compose project
+
+Logs:
+
+```
+docker compose -f ~/.config/telegram-ask/compose/compose.yaml logs -f
+```
+
+This target is untested on real Docker so far.
+
+### systemd (npm)
+
+No container. `init` installs the package globally with npm (`npm i -g`), or into `~/.local/share/telegram-ask/npm` if the global prefix isn't writable. If you ran `init` from an already-installed copy, it uses that. Written:
+
+- `~/.config/telegram-ask/config.json` (token, port, owner)
+- `~/.config/systemd/user/telegram-ask.service` with absolute paths to `node`, the CLI and the config file (`TELEGRAM_ASK_CONFIG` is always set in the unit, and `install.json` records the same path)
+
+Logs: `journalctl --user -u telegram-ask -f`. Linger is handled as for Quadlet.
+
+Config is read from `$TELEGRAM_ASK_CONFIG`, else `$XDG_CONFIG_HOME/telegram-ask/config.json`, else `~/.config/telegram-ask/config.json`. The env vars `BOT_TOKEN`, `OWNER_ID`, `PORT` and `HOST` override the file. `HOST` defaults to `127.0.0.1` (the container targets set `0.0.0.0` inside the container and publish only on `127.0.0.1`).
+
+## Commands
+
+```
+telegram-ask init [systemd|compose|quadlet] [--port N]
+telegram-ask status
+telegram-ask test
+telegram-ask reset-owner
+telegram-ask uninstall
+telegram-ask start
+```
+
+- `status`: target, version, port, whether it's running, and pairing state (with the code if unpaired).
+- `test`: sends "This is a test" with Approve/Decline buttons (Decline on timeout) and prints the response.
+- `uninstall`: stops and removes the service, then asks whether to also delete the bot token and paired owner. Answer no to keep them: `config.json` (systemd) or the target's `.env` and volume stay on disk, and a later `init` finds them and reuses the token and owner without asking. Yes also removes the target's image, volume and files. For systemd the npm package stays; `uninstall` prints the command to remove it, `npm rm -g telegram-ask`, or `npm rm -g --prefix ~/.local/share/telegram-ask/npm telegram-ask` if `init` installed it into that prefix.
+- `start`: runs the service in the foreground. The installed services use this.
+
+## One instance per token
+
+Only one instance can run per bot token; two would fight over Telegram's updates. `init` replaces an existing install rather than adding a second. Stop anything you started by hand, including a `docker run` container, before running `init`.
+
+## Upgrading from the old setup
+
+Earlier versions used `npm run onboard` and `deploy/install-service.sh`. `init` recognizes that systemd unit as a legacy install, offers to replace it, and reuses the token and owner from the existing config. Stop any hand-run Docker container using the same token first. The old config file is kept and reused if you pick the systemd target.
+
+## API
+
+`POST /request` on `127.0.0.1:<port>`, JSON body:
+
+| Field           | Type     | Required | Notes                                                  |
+| --------------- | -------- | -------- | ------------------------------------------------------ |
+| `text`          | string   | yes      | Question shown in Telegram. Non-empty, max 3900 chars. |
+| `options`       | string[] | yes      | Button labels. Non-empty, unique, non-empty strings.   |
+| `timeoutOption` | string   | yes      | Answer returned on timeout. Must be one of `options`.  |
+| `timeout`       | number   | no       | Seconds. Default and max 300. Must be positive.        |
+
+The request stays open until you tap a button or the timeout fires, then returns `200`:
+
+```json
+{ "answer": "Approve", "timedOut": false }
+```
+
+On timeout, `answer` is `timeoutOption` and `timedOut` is `true`. Many requests can be pending at once.
+
+```
+curl -s -X POST http://127.0.0.1:8787/request \
+  -H 'content-type: application/json' \
+  -d '{"text":"Deploy?","options":["Approve","Decline"],"timeoutOption":"Decline","timeout":60}'
+```
+
+Errors are JSON `{ "error": "..." }`:
+
+| Status | Meaning                                                                 |
+| ------ | ----------------------------------------------------------------------- |
+| 400    | Body isn't valid JSON or fails validation. Nothing is sent to Telegram. |
+| 413    | Body over 64 KiB.                                                       |
+| 502    | Telegram message couldn't be sent.                                      |
+| 500    | Internal error, or the request was cancelled.                           |
+| 404    | Path isn't `/request`.                                                  |
+| 405    | Method isn't POST.                                                      |
+
+If the caller disconnects early, the request is dropped and the Telegram message is edited to a "cancelled" line. Pending requests live in memory, so a restart drops them (callers see a connection error).
+
+## Security
+
+There's no auth. The API is meant for localhost only; don't expose it. The container targets publish the port on `127.0.0.1` only; keep it that way.

package/dist/approval/constants.js

@@ -0,0 +1,10 @@
+/** Hard cap on a request's timeout; also the timeout when the client sends none. */
+export const MAX_TIMEOUT_SECONDS = 300;
+/** Longest allowed option label, in characters. */
+export const MAX_OPTION_LENGTH = 64;
+/** Leaves room for the appended result line under Telegram's 4096 message limit. */
+export const MAX_TEXT_LENGTH = 3900;
+/** Shared settlement for a request cancelled before an answer. */
+export const CANCELLED_SETTLEMENT = { kind: 'cancelled' };
+/** Shared result for `ApprovalService.request` when its signal aborted. */
+export const CANCELLED_RESULT = { kind: 'cancelled' };

package/dist/approval/formatter.js

@@ -0,0 +1,27 @@
+function formatTime(at) {
+    const hours = String(at.getHours()).padStart(2, '0');
+    const minutes = String(at.getMinutes()).padStart(2, '0');
+    return `${hours}:${minutes}`;
+}
+/**
+ * One-line outcome shown under the request: answer, timeout or cancellation, with the local time as
+ * HH:MM.
+ */
+export function formatResultLine(settlement, at) {
+    const time = formatTime(at);
+    switch (settlement.kind) {
+        case 'answered':
+            return `✅ ${settlement.answer}, ${time}`;
+        case 'timedOut':
+            return `⏱ Timed out, ${settlement.answer}, ${time}`;
+        case 'cancelled':
+            return `🚫 Cancelled, ${time}`;
+    }
+}
+/**
+ * The original request text, a blank line, then the result line; this replaces the message once
+ * settled.
+ */
+export function formatFinalText(original, settlement, at) {
+    return `${original}\n\n${formatResultLine(settlement, at)}`;
+}

package/dist/approval/index.js

@@ -0,0 +1,5 @@
+export { MAX_OPTION_LENGTH, MAX_TEXT_LENGTH, MAX_TIMEOUT_SECONDS } from './constants.js';
+export { formatFinalText, formatResultLine } from './formatter.js';
+export { parseApprovalRequest } from './parser.js';
+export { PendingRequests } from './pending.js';
+export { ApprovalService, SendError } from './service.js';

package/dist/approval/parser.js

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { MAX_OPTION_LENGTH, MAX_TEXT_LENGTH, MAX_TIMEOUT_SECONDS } from './constants.js';
+const TEXT_ERROR = 'text must be a non-empty string';
+const OPTIONS_ERROR = 'options must be a non-empty array';
+const OPTION_ERROR = `options must contain only non-empty strings of at most ${MAX_OPTION_LENGTH} characters`;
+const TIMEOUT_ERROR = 'timeout must be a finite positive number';
+// Messages are part of the API (README error table); only the first issue is reported.
+const approvalRequestSchema = z
+    .object({
+    text: z
+        .string({ error: TEXT_ERROR })
+        .refine((text) => text.trim().length > 0, TEXT_ERROR)
+        .refine((text) => text.length <= MAX_TEXT_LENGTH, `text must be at most ${MAX_TEXT_LENGTH} characters`),
+    options: z
+        .array(z
+        .string({ error: OPTION_ERROR })
+        .min(1, OPTION_ERROR)
+        .max(MAX_OPTION_LENGTH, OPTION_ERROR), {
+        error: OPTIONS_ERROR,
+    })
+        .min(1, OPTIONS_ERROR)
+        .refine((options) => new Set(options).size === options.length, 'options must be unique'),
+    timeoutOption: z.string({ error: 'timeoutOption must be a string' }),
+    timeout: z.number({ error: TIMEOUT_ERROR }).positive(TIMEOUT_ERROR).optional(),
+}, { error: 'body must be a JSON object' })
+    .refine((body) => body.options.includes(body.timeoutOption), 'timeoutOption must be one of options')
+    .transform(({ text, options, timeoutOption, timeout }) => ({
+    text,
+    options,
+    timeoutOption,
+    timeoutSeconds: Math.min(timeout ?? MAX_TIMEOUT_SECONDS, MAX_TIMEOUT_SECONDS),
+}));
+/**
+ * Validates a request body; never throws. Returns the first problem as `error`, and clamps
+ * `timeout` to the cap (the cap is also the default).
+ */
+export function parseApprovalRequest(body) {
+    const result = approvalRequestSchema.safeParse(body);
+    if (result.success) {
+        return { ok: true, value: result.data };
+    }
+    return { ok: false, error: result.error.issues[0]?.message ?? 'invalid request' };
+}

package/dist/approval/pending.js

@@ -0,0 +1,47 @@
+import { CANCELLED_SETTLEMENT } from './constants.js';
+/**
+ * Open requests by id, each settling exactly once (answer, timeout or cancel); settling clears its
+ * timer.
+ */
+export class PendingRequests {
+    #entries = new Map();
+    get size() {
+        return this.#entries.size;
+    }
+    /**
+     * Registers `request` and resolves with how it settled. The timeout settles it with the request's
+     * timeout option.
+     */
+    open(id, request) {
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => this.#settle(id, { kind: 'timedOut', answer: request.timeoutOption }), request.timeoutSeconds * 1000);
+            this.#entries.set(id, { request, timer, resolve });
+        });
+    }
+    /**
+     * Settles with the option at `optionIndex`; false when the id is unknown or already settled, or
+     * the index is out of range.
+     */
+    answer(id, optionIndex) {
+        const entry = this.#entries.get(id);
+        const answer = entry?.request.options[optionIndex];
+        if (answer === undefined) {
+            return false;
+        }
+        return this.#settle(id, { kind: 'answered', answer });
+    }
+    /** Settles as cancelled; false when the id is unknown or already settled. */
+    cancel(id) {
+        return this.#settle(id, CANCELLED_SETTLEMENT);
+    }
+    #settle(id, settlement) {
+        const entry = this.#entries.get(id);
+        if (!entry) {
+            return false;
+        }
+        clearTimeout(entry.timer);
+        this.#entries.delete(id);
+        entry.resolve(settlement);
+        return true;
+    }
+}

package/dist/approval/service.js

@@ -0,0 +1,65 @@
+import { CANCELLED_RESULT } from './constants.js';
+import { formatFinalText } from './formatter.js';
+import { PendingRequests } from './pending.js';
+/** The messenger failed to send the request; the original error is in `cause`. */
+export class SendError extends Error {
+}
+/** Sends each request to the owner and waits for a tap, the timeout or an abort. */
+export class ApprovalService {
+    #messenger;
+    #now;
+    #newId;
+    #pending = new PendingRequests();
+    constructor(messenger, now = () => new Date(), newId = () => crypto.randomUUID()) {
+        this.#messenger = messenger;
+        this.#now = now;
+        this.#newId = newId;
+    }
+    /**
+     * Resolves once settled. Throws `SendError` if the message can't be sent; a failed final edit is
+     * only logged. An aborted `signal` settles as cancelled.
+     */
+    async request(request, signal) {
+        const id = this.#newId();
+        let reference;
+        try {
+            reference = await this.#messenger.sendRequest(id, request.text, request.options);
+        }
+        catch (cause) {
+            throw new SendError('failed to send approval request', { cause });
+        }
+        const settled = this.#pending.open(id, request);
+        const onAbort = () => {
+            this.#pending.cancel(id);
+        };
+        // Checked after open() so an abort during sendRequest is not missed.
+        if (signal?.aborted) {
+            onAbort();
+        }
+        else {
+            signal?.addEventListener('abort', onAbort, { once: true });
+        }
+        const settlement = await settled;
+        signal?.removeEventListener('abort', onAbort);
+        try {
+            await this.#messenger.finalize(reference, formatFinalText(request.text, settlement, this.#now()));
+        }
+        catch (error) {
+            console.error('failed to finalize approval message', error);
+        }
+        if (settlement.kind === 'cancelled') {
+            return CANCELLED_RESULT;
+        }
+        return {
+            kind: 'completed',
+            outcome: { answer: settlement.answer, timedOut: settlement.kind === 'timedOut' },
+        };
+    }
+    /**
+     * Records a button tap; 'expired' when the request is unknown, already settled or the index is
+     * invalid.
+     */
+    tap(id, optionIndex) {
+        return this.#pending.answer(id, optionIndex) ? 'accepted' : 'expired';
+    }
+}

package/dist/approval/types.js

@@ -0,0 +1 @@
+export {};