telegram-ask 0.1.1

package/dist/cli.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+import { Argument, Command, CommanderError, InvalidArgumentError, Option } from 'commander';
+import { realpathSync } from 'node:fs';
+import os from 'node:os';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createClackPrompts, defaultFetchStatus, runInit, runOwner, runResetOwner, runStatus, runTest, runUninstall, waitForPairing, } from './commands/index.js';
+import { DEFAULT_PORT, loadConfig, VERSION } from './config/index.js';
+import { runService } from './daemon/index.js';
+import { createTargets, resolveInstallPaths, TARGET_ORDER } from './install/index.js';
+import { isPortFree, realExec, validateToken } from './system/index.js';
+const PORT_PATTERN = /^\d+$/;
+function resolvePort() {
+    try {
+        return loadConfig().port;
+    }
+    catch {
+        const port = Number(process.env.PORT);
+        return Number.isInteger(port) && port > 0 ? port : DEFAULT_PORT;
+    }
+}
+function parsePort(rawPort) {
+    const port = PORT_PATTERN.test(rawPort) ? Number(rawPort) : NaN;
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new InvalidArgumentError('must be an integer 1-65535');
+    }
+    return port;
+}
+function runInitCommand(args) {
+    const paths = resolveInstallPaths();
+    const targets = createRealTargets(paths);
+    return runWithSigint((controller) => runInit(args, {
+        targets,
+        paths,
+        prompt: createClackPrompts(controller.signal),
+        validateToken,
+        isPortFree,
+        wait: waitForPairing,
+        print: (text) => console.log(text),
+        signal: controller.signal,
+        version: VERSION,
+    }));
+}
+function createRealTargets(paths) {
+    return createTargets({ exec: realExec, paths, env: process.env, user: os.userInfo().username }, { selfPath: realpathSync(fileURLToPath(import.meta.url)), nodePath: process.execPath });
+}
+async function runWithSigint(run) {
+    const controller = new AbortController();
+    const onSigint = () => controller.abort();
+    process.on('SIGINT', onSigint);
+    try {
+        return await run(controller);
+    }
+    finally {
+        process.off('SIGINT', onSigint);
+    }
+}
+function runStatusCommand() {
+    const paths = resolveInstallPaths();
+    return runStatus({
+        targets: createRealTargets(paths),
+        paths,
+        fetchStatus: defaultFetchStatus,
+        print: (text) => console.log(text),
+    });
+}
+function runResetOwnerCommand() {
+    const paths = resolveInstallPaths();
+    const targets = createRealTargets(paths);
+    return runWithSigint((controller) => runResetOwner({
+        targets,
+        paths,
+        confirm: createClackPrompts(controller.signal).confirm,
+        wait: waitForPairing,
+        print: (text) => console.log(text),
+        signal: controller.signal,
+    }));
+}
+function runUninstallCommand() {
+    const paths = resolveInstallPaths();
+    const targets = createRealTargets(paths);
+    return runWithSigint((controller) => runUninstall({
+        targets,
+        paths,
+        confirm: createClackPrompts(controller.signal).confirm,
+        print: (text) => console.log(text),
+        signal: controller.signal,
+    }));
+}
+/** Takes argv without node and script path; returns the exit code (2 for usage errors). */
+export async function main(argv) {
+    let code = 0;
+    const program = new Command('telegram-ask').version(VERSION, '-v, --version').exitOverride();
+    program
+        .command('init')
+        .description('set up the bot token and install the service')
+        .addArgument(new Argument('[target]').choices(TARGET_ORDER))
+        .option('--port <n>', "API port (default 8787, or the existing install's)", parsePort)
+        // Installs an unpublished build; for testing.
+        .addOption(new Option('--tarball <path>').hideHelp())
+        .action(async (target, options) => {
+        code = await runInitCommand({
+            ...(target ? { target } : {}),
+            ...(options.port === undefined ? {} : { port: options.port }),
+            ...(options.tarball === undefined ? {} : { tarball: resolve(options.tarball) }),
+        });
+    });
+    program
+        .command('start')
+        .description('run the service in the foreground')
+        .action(() => runService());
+    program
+        .command('status')
+        .description('show service and pairing state')
+        .action(async () => {
+        code = await runStatusCommand();
+    });
+    program
+        .command('test')
+        .description('send a test approval request')
+        .action(async () => {
+        code = await runTest(resolvePort(), resolveInstallPaths().installFile);
+    });
+    program
+        .command('reset-owner')
+        .description('clear the paired owner so a new one can pair')
+        .action(async () => {
+        code = await runResetOwnerCommand();
+    });
+    program
+        .command('uninstall')
+        .description('remove the service')
+        .action(async () => {
+        code = await runUninstallCommand();
+    });
+    // Runs inside containers to read or clear the owner in the data volume.
+    program
+        .command('owner', { hidden: true })
+        .argument('[args...]')
+        .action((args) => {
+        code = runOwner(args);
+    });
+    try {
+        await program.parseAsync(argv.length === 0 ? ['--help'] : argv, { from: 'user' });
+    }
+    catch (error) {
+        if (!(error instanceof CommanderError)) {
+            throw error;
+        }
+        // Help and version exit 0; usage errors (already printed) exit 2.
+        return error.exitCode === 0 ? 0 : 2;
+    }
+    return code;
+}
+if (import.meta.main) {
+    const code = await main(process.argv.slice(2));
+    // `start` keeps the process alive via the server and bot; only exit for other commands.
+    if (process.argv[2] !== 'start') {
+        process.exit(code);
+    }
+}

package/dist/commands/constants.js

@@ -0,0 +1,14 @@
+/** Display names for the install target prompt. */
+export const TARGET_LABELS = {
+    quadlet: 'Podman Quadlet (user service)',
+    compose: 'Docker Compose',
+    systemd: 'systemd user service (npm)',
+};
+/** How long to wait for the service to answer /status for the first time. */
+export const DEFAULT_START_TIMEOUT_MS = 60_000;
+/** Delay between /status polls while waiting for pairing. */
+export const POLL_INTERVAL_MS = 1000;
+/** Per-request timeout for one /status call. */
+export const STATUS_TIMEOUT_MS = 2000;
+/** Strips the dash from a displayed pairing code to build the t.me deep link. */
+export const CODE_DASH_PATTERN = /-/g;

package/dist/commands/index.js

@@ -0,0 +1,8 @@
+export { runInit } from './init.js';
+export { runOwner } from './owner.js';
+export { defaultFetchStatus, waitForPairing } from './pairing-wait.js';
+export { createClackPrompts, PromptAborted } from './prompts.js';
+export { runResetOwner } from './reset-owner.js';
+export { runStatus } from './status.js';
+export { runTest } from './test.js';
+export { runUninstall } from './uninstall.js';

package/dist/commands/init.js

@@ -0,0 +1,159 @@
+import { DEFAULT_PORT } from '../config/index.js';
+import { detectTargets, findDefaultTarget, findExistingInstall, findLeftoverSecrets, writeInstall, } from '../install/index.js';
+import { TARGET_LABELS } from './constants.js';
+import { PromptAborted } from './prompts.js';
+async function findBotUsername(deps, token) {
+    try {
+        return await deps.validateToken(token);
+    }
+    catch {
+        return undefined;
+    }
+}
+class Aborted extends Error {
+}
+function redact(message, secrets) {
+    let redacted = message;
+    for (const secret of secrets) {
+        if (secret !== '') {
+            redacted = redacted.replaceAll(secret, '***');
+        }
+    }
+    return redacted;
+}
+/**
+ * Installs or replaces the service and waits for pairing. Returns 0 on success or when the user
+ * declines, 1 on failure, 130 on interrupt; error text is shown with known tokens masked.
+ */
+export async function runInit(args, deps) {
+    // Every token string init has seen, so error messages can be shown with them masked.
+    const seen = [];
+    try {
+        return await runInitInner(args, deps, seen);
+    }
+    catch (error) {
+        if (error instanceof Aborted || error instanceof PromptAborted || deps.signal?.aborted) {
+            deps.print('');
+            return 130;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        deps.print(`Install failed: ${redact(message, seen)}`);
+        deps.print('Run telegram-ask init again. Check the logs for details.');
+        return 1;
+    }
+}
+async function runInitInner(args, deps, seen) {
+    const { print, prompt } = deps;
+    const env = deps.env ?? process.env;
+    const detected = await detectTargets(deps.targets);
+    let name;
+    if (args.target) {
+        const chosen = detected.find((candidate) => candidate.name === args.target);
+        if (!chosen?.ok) {
+            print(`Cannot use ${args.target}: ${chosen?.reason ?? 'unavailable'}`);
+            return 1;
+        }
+        name = args.target;
+    }
+    else {
+        const defaultName = findDefaultTarget(detected);
+        if (!defaultName) {
+            print('No install target is available:');
+            for (const candidate of detected) {
+                if (!candidate.ok) {
+                    print(`  ${candidate.name}: ${candidate.reason}`);
+                }
+            }
+            return 1;
+        }
+        name = await prompt.select('Where should the bot run?', detected.map((candidate) => ({
+            value: candidate.name,
+            label: TARGET_LABELS[candidate.name],
+            ...(candidate.ok ? {} : { disabled: candidate.reason }),
+        })), defaultName);
+    }
+    const target = deps.targets[name];
+    let secrets = {};
+    let record;
+    const existing = findExistingInstall(deps.paths, deps.targets, env);
+    if (existing) {
+        record = existing.record;
+        print(`Found an existing ${record.target} install (version ${record.version}, port ${record.port}).` +
+            (existing.legacy ? ' It looks like a legacy install from an older setup.' : ''));
+        if (!(await prompt.confirm('Replace it?', true))) {
+            return 0;
+        }
+        const old = deps.targets[record.target];
+        secrets = await old.readSecrets(record);
+        if (secrets.token) {
+            seen.push(secrets.token);
+        }
+        // Record a legacy install too, so a failed run below can still find its config on retry.
+        if (existing.legacy) {
+            writeInstall(deps.paths.installFile, record);
+        }
+        // Remove first: the old service may hold the port we're about to check. install.json stays
+        // until the new install replaces it; remove() keeps the secrets and is safe to repeat.
+        await old.remove(record, false);
+    }
+    else {
+        secrets = findLeftoverSecrets(deps.paths, env);
+        if (secrets.token) {
+            seen.push(secrets.token);
+            print('Found a bot token kept from an earlier install.');
+        }
+    }
+    let token;
+    if (secrets.token) {
+        const bot = await findBotUsername(deps, secrets.token);
+        if (bot) {
+            token = secrets.token;
+            print(`Reusing the saved bot token (@${bot}).`);
+        }
+    }
+    while (token === undefined) {
+        if (deps.signal?.aborted) {
+            throw new Aborted();
+        }
+        const candidate = await prompt.password('Bot token');
+        seen.push(candidate);
+        if (candidate !== '' && (await findBotUsername(deps, candidate))) {
+            token = candidate;
+        }
+        else {
+            print('Telegram rejected that token (or could not be reached). Try again.');
+        }
+    }
+    const port = args.port ?? record?.port ?? DEFAULT_PORT;
+    if (!(await deps.isPortFree(port))) {
+        print(`Port ${port} is in use. Pick another with --port.`);
+        return 1;
+    }
+    const installed = await target.install({
+        version: deps.version,
+        port,
+        token,
+        ...(secrets.ownerId === undefined ? {} : { ownerId: secrets.ownerId }),
+        ...(args.tarball === undefined ? {} : { tarball: args.tarball }),
+        print,
+    });
+    writeInstall(deps.paths.installFile, installed);
+    const result = await deps.wait({
+        port,
+        isRunning: () => target.isRunning(installed),
+        logsHint: target.logsHint(installed),
+        ...(deps.signal ? { signal: deps.signal } : {}),
+        print,
+    });
+    if (result === 'paired') {
+        print('Done. Try it: telegram-ask test');
+        print('Check state: telegram-ask status');
+        print(`Logs: ${target.logsHint(installed)}`);
+        return 0;
+    }
+    if (result === 'interrupted') {
+        return 130;
+    }
+    print(target.logsHint(installed));
+    return 1;
+}

package/dist/commands/owner.js

@@ -0,0 +1,18 @@
+import { readConfigFile, resolveConfigPath, updateConfigFile } from '../config/index.js';
+/** Hidden helper; runs inside containers so the CLI can read/clear the owner in the data volume. */
+export function runOwner(args, env = process.env) {
+    const path = resolveConfigPath(env);
+    if (args[0] === 'get') {
+        const id = readConfigFile(path).ownerId;
+        if (id !== undefined) {
+            console.log(String(id));
+        }
+        return 0;
+    }
+    if (args[0] === 'clear') {
+        updateConfigFile(path, { ownerId: null });
+        return 0;
+    }
+    console.error('Usage: owner get|clear');
+    return 2;
+}

package/dist/commands/pairing-wait.js

@@ -0,0 +1,65 @@
+import { setTimeout as delay } from 'node:timers/promises';
+import { statusInfoSchema } from '../server/index.js';
+import { CODE_DASH_PATTERN, DEFAULT_START_TIMEOUT_MS, POLL_INTERVAL_MS, STATUS_TIMEOUT_MS, } from './constants.js';
+/**
+ * GETs the local /status; undefined on any failure or unexpected body (typically the service isn't
+ * up yet).
+ */
+export async function defaultFetchStatus(port) {
+    try {
+        const response = await fetch(`http://127.0.0.1:${port}/status`, {
+            signal: AbortSignal.timeout(STATUS_TIMEOUT_MS),
+        });
+        const body = statusInfoSchema.safeParse(await response.json());
+        if (body.success) {
+            return body.data;
+        }
+    }
+    catch {
+        // not up yet
+    }
+    return undefined;
+}
+function createAbortableSleep(signal) {
+    // Rejects on abort; the loop checks the signal right after.
+    return (delayMs) => delay(delayMs, undefined, { signal }).catch(() => { });
+}
+/**
+ * Polls /status, printing the pairing code once. Start timeout only applies until the service first
+ * answers; ends as paired, interrupted, stopped (not running) or notStarted.
+ */
+export async function waitForPairing(options) {
+    const print = options.print ?? ((text) => console.log(text));
+    const fetchStatus = options.fetchStatus ?? defaultFetchStatus;
+    const sleep = options.sleep ?? createAbortableSleep(options.signal);
+    const startTimeoutMs = options.startTimeoutMs ?? DEFAULT_START_TIMEOUT_MS;
+    const began = Date.now();
+    let answered = false;
+    let shown = false;
+    for (;;) {
+        if (options.signal?.aborted) {
+            print('Service is still running and waiting for pairing. Run "telegram-ask status" to see the code again.');
+            return 'interrupted';
+        }
+        const status = await fetchStatus(options.port);
+        if (status) {
+            answered = true;
+            if (status.paired) {
+                return 'paired';
+            }
+            if (!shown) {
+                shown = true;
+                const rawCode = status.code.replace(CODE_DASH_PATTERN, '');
+                print(`Pairing code: ${status.code}\nSend "/start ${status.code}" to @${status.bot}, or open https://t.me/${status.bot}?start=${rawCode}`);
+            }
+        }
+        else if (!answered && Date.now() - began >= startTimeoutMs) {
+            return 'notStarted';
+        }
+        if (!(await options.isRunning())) {
+            print(`The service stopped. ${options.logsHint}`);
+            return 'stopped';
+        }
+        await sleep(POLL_INTERVAL_MS);
+    }
+}

package/dist/commands/prompts.js

@@ -0,0 +1,55 @@
+import { confirm, isCancel, password, select } from '@clack/prompts';
+/**
+ * Thrown by the prompts on Ctrl-C, abort, or when stdin isn't a terminal; callers treat it as a
+ * user cancel.
+ */
+export class PromptAborted extends Error {
+    constructor() {
+        super('prompt aborted');
+        this.name = 'PromptAborted';
+    }
+}
+// Clack never settles on a closed or piped stdin, so refuse up front.
+function requireTty() {
+    if (!process.stdin.isTTY) {
+        throw new PromptAborted();
+    }
+}
+function requireAnswer(value) {
+    if (isCancel(value)) {
+        throw new PromptAborted();
+    }
+    return value;
+}
+/**
+ * Clack-backed prompts. Each rejects with PromptAborted on Ctrl-C, when `signal` aborts, or when
+ * stdin isn't a terminal.
+ */
+export function createClackPrompts(signal) {
+    return {
+        confirm: async (message, initialValue) => {
+            requireTty();
+            return requireAnswer(await confirm({ message, initialValue, signal }));
+        },
+        password: async (message) => {
+            requireTty();
+            return requireAnswer(await password({ message, signal })).trim();
+        },
+        select: async (message, options, initialValue) => {
+            requireTty();
+            // select<string>: clack's Option<T> is a conditional type TS can't check against a generic T.
+            return requireAnswer(await select({
+                message,
+                initialValue,
+                signal,
+                options: options.map((option) => ({
+                    value: option.value,
+                    label: option.disabled
+                        ? `${option.label} (unavailable: ${option.disabled})`
+                        : option.label,
+                    disabled: option.disabled !== undefined,
+                })),
+            }));
+        },
+    };
+}

package/dist/commands/reset-owner.js

@@ -0,0 +1,58 @@
+import { findExistingInstall } from '../install/index.js';
+import { PromptAborted } from './prompts.js';
+/**
+ * Unlinks the paired owner, restarts the service and waits for a new pairing. Returns 0 on success
+ * or if the user declines, 1 on failure or not installed, 130 on interrupt.
+ */
+export async function runResetOwner(deps) {
+    const { print } = deps;
+    const existing = findExistingInstall(deps.paths, deps.targets);
+    if (!existing) {
+        print('Not installed. Run "telegram-ask init".');
+        return 1;
+    }
+    const { record } = existing;
+    const target = deps.targets[record.target];
+    try {
+        if (!(await deps.confirm('This unlinks your Telegram account. Continue?', false))) {
+            return 0;
+        }
+        await target.clearOwner(record);
+        await target.restart(record);
+    }
+    catch (error) {
+        if (error instanceof PromptAborted || deps.signal?.aborted) {
+            print('');
+            return 130;
+        }
+        print(`Reset failed. ${target.logsHint(record)}`);
+        return 1;
+    }
+    let result;
+    try {
+        result = await deps.wait({
+            port: record.port,
+            isRunning: () => target.isRunning(record),
+            logsHint: target.logsHint(record),
+            ...(deps.signal ? { signal: deps.signal } : {}),
+            print,
+        });
+    }
+    catch {
+        if (deps.signal?.aborted) {
+            print('');
+            return 130;
+        }
+        print(`Waiting for pairing failed. ${target.logsHint(record)}`);
+        return 1;
+    }
+    if (result === 'paired') {
+        print('Paired. Try it: telegram-ask test');
+        return 0;
+    }
+    if (result === 'interrupted') {
+        return 130;
+    }
+    print(target.logsHint(record));
+    return 1;
+}

package/dist/commands/status.js

@@ -0,0 +1,42 @@
+import { findExistingInstall } from '../install/index.js';
+import { CODE_DASH_PATTERN } from './constants.js';
+/**
+ * Prints install, running and pairing state. Returns 0 only when installed and running; 1
+ * otherwise.
+ */
+export async function runStatus(deps) {
+    const { print } = deps;
+    const existing = findExistingInstall(deps.paths, deps.targets);
+    if (!existing) {
+        print('Not installed. Run "telegram-ask init".');
+        return 1;
+    }
+    const { record } = existing;
+    let running = false;
+    try {
+        running = await deps.targets[record.target].isRunning(record);
+    }
+    catch {
+        running = false;
+    }
+    print(`Target:  ${record.target}`);
+    print(`Version: ${record.version}`);
+    print(`Port:    ${record.port}`);
+    print(`Running: ${running ? 'yes' : 'no'}`);
+    if (!running) {
+        print(deps.targets[record.target].logsHint(record));
+        return 1;
+    }
+    const status = await deps.fetchStatus(record.port);
+    if (!status) {
+        print('Pairing: unknown (the service did not answer on /status yet)');
+    }
+    else if (status.paired) {
+        print('Pairing: paired');
+    }
+    else {
+        const rawCode = status.code.replace(CODE_DASH_PATTERN, '');
+        print(`Pairing: not paired\nPairing code: ${status.code}\nSend "/start ${status.code}" to @${status.bot}, or open https://t.me/${status.bot}?start=${rawCode}`);
+    }
+    return 0;
+}

package/dist/commands/test.js

@@ -0,0 +1,22 @@
+import { readInstall } from '../install/index.js';
+/** Port from install.json when present, else the fallback. */
+export async function runTest(fallbackPort, installFile) {
+    const port = (installFile ? readInstall(installFile)?.port : undefined) ?? fallbackPort;
+    try {
+        const response = await fetch(`http://127.0.0.1:${port}/request`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({
+                text: 'This is a test',
+                options: ['Approve', 'Decline'],
+                timeoutOption: 'Decline',
+            }),
+        });
+        console.log(response.status, await response.text());
+        return response.status === 200 ? 0 : 1;
+    }
+    catch (error) {
+        console.error(`could not reach the service on port ${port} (is it running? try telegram-ask status): ${error instanceof Error ? error.message : String(error)}`);
+        return 1;
+    }
+}

package/dist/commands/types.js

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

package/dist/commands/uninstall.js

@@ -0,0 +1,30 @@
+import { findExistingInstall, removeInstall } from '../install/index.js';
+import { PromptAborted } from './prompts.js';
+/**
+ * Removes the service after asking whether to purge the token and owner. Returns 0 on success or
+ * when nothing is installed, 1 on failure, 130 on interrupt.
+ */
+export async function runUninstall(deps) {
+    const { print } = deps;
+    const existing = findExistingInstall(deps.paths, deps.targets);
+    if (!existing) {
+        print('Not installed.');
+        return 0;
+    }
+    const { record } = existing;
+    try {
+        const purge = await deps.confirm('Also delete the bot token and paired owner?', false);
+        await deps.targets[record.target].remove(record, purge);
+        removeInstall(deps.paths.installFile);
+    }
+    catch (error) {
+        if (error instanceof PromptAborted || deps.signal?.aborted) {
+            print('');
+            return 130;
+        }
+        print('Uninstall failed. Check the service logs and try again.');
+        return 1;
+    }
+    print('Uninstalled.');
+    return 0;
+}

package/dist/config/constants.js

@@ -0,0 +1,13 @@
+import packageJson from '../../package.json' with { type: 'json' };
+/** Package version, read from package.json when the module loads. */
+export const VERSION = packageJson.version;
+/** Port used when neither the env nor the config file sets one. */
+export const DEFAULT_PORT = 8787;
+/** Loopback only; the container image overrides it with HOST=0.0.0.0. */
+export const DEFAULT_HOST = '127.0.0.1';
+/** Appended to config errors so the user knows how to fix them. */
+export const INIT_HINT = 'run `telegram-ask init` to set up the bot';
+/** Accepts optionally signed whole numbers in env values. */
+export const INTEGER_PATTERN = /^-?\d+$/;
+/** Owner read/write only, for files that hold the bot token. */
+export const SECRET_FILE_MODE = 0o600;

package/dist/config/index.js

@@ -0,0 +1,2 @@
+export { DEFAULT_PORT, VERSION } from './constants.js';
+export { loadConfig, readConfigFile, resolveConfigDirectory, resolveConfigPath, updateConfigFile, } from './store.js';

package/dist/config/schema.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+/** Loose so unknown keys survive `updateConfigFile`'s read-modify-write. */
+export const fileConfigSchema = z.looseObject({
+    botToken: z.string().optional(),
+    ownerId: z.number().optional(),
+    port: z.number().optional(),
+});