opencode-telegram-group-topics-bot 0.11.2

package/dist/runtime/bootstrap.js

@@ -0,0 +1,350 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import readline from "node:readline";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import dotenv from "dotenv";
+import { getRuntimePaths } from "./paths.js";
+import { getLocale, getLocaleOptions, resolveSupportedLocale, setRuntimeLocale, t, } from "../i18n/index.js";
+const DEFAULT_API_URL = "http://localhost:4096";
+const DEFAULT_SERVER_USERNAME = "opencode";
+const FALLBACK_MODEL_PROVIDER = "opencode";
+const FALLBACK_MODEL_ID = "big-pickle";
+function isPositiveInteger(value) {
+    return /^[1-9]\d*$/.test(value);
+}
+function isValidHttpUrl(value) {
+    try {
+        const parsed = new URL(value);
+        return parsed.protocol === "http:" || parsed.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}
+export function validateRuntimeEnvValues(values) {
+    if (!values.TELEGRAM_BOT_TOKEN || values.TELEGRAM_BOT_TOKEN.trim().length === 0) {
+        return { isValid: false, reason: "Missing TELEGRAM_BOT_TOKEN" };
+    }
+    if (!isPositiveInteger(values.TELEGRAM_ALLOWED_USER_ID || "")) {
+        return { isValid: false, reason: "Invalid TELEGRAM_ALLOWED_USER_ID" };
+    }
+    if (!values.OPENCODE_MODEL_PROVIDER || values.OPENCODE_MODEL_PROVIDER.trim().length === 0) {
+        return { isValid: false, reason: "Missing OPENCODE_MODEL_PROVIDER" };
+    }
+    if (!values.OPENCODE_MODEL_ID || values.OPENCODE_MODEL_ID.trim().length === 0) {
+        return { isValid: false, reason: "Missing OPENCODE_MODEL_ID" };
+    }
+    const apiUrl = values.OPENCODE_API_URL?.trim();
+    if (apiUrl && !isValidHttpUrl(apiUrl)) {
+        return { isValid: false, reason: "Invalid OPENCODE_API_URL" };
+    }
+    return { isValid: true };
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizeEnvLineEndings(content) {
+    const lines = content.split(/\r?\n/).map((line) => line.replace(/\r$/, ""));
+    while (lines.length > 0 && lines[lines.length - 1] === "") {
+        lines.pop();
+    }
+    return lines;
+}
+function removeEnvKey(lines, key) {
+    const regex = new RegExp(`^\\s*(?:export\\s+)?${escapeRegex(key)}\\s*=`);
+    return lines.filter((line) => !regex.test(line));
+}
+function finalizeEnvContent(lines) {
+    return `${lines.join("\n")}\n`;
+}
+export function buildEnvFileContent(existingContent, values) {
+    let lines = normalizeEnvLineEndings(existingContent);
+    const orderedUpdates = [
+        ["BOT_LOCALE", values.BOT_LOCALE],
+        ["TELEGRAM_BOT_TOKEN", values.TELEGRAM_BOT_TOKEN],
+        ["TELEGRAM_ALLOWED_USER_ID", values.TELEGRAM_ALLOWED_USER_ID],
+        ["OPENCODE_API_URL", values.OPENCODE_API_URL],
+        ["OPENCODE_SERVER_USERNAME", values.OPENCODE_SERVER_USERNAME],
+        ["OPENCODE_SERVER_PASSWORD", values.OPENCODE_SERVER_PASSWORD],
+        ["OPENCODE_MODEL_PROVIDER", values.OPENCODE_MODEL_PROVIDER],
+        ["OPENCODE_MODEL_ID", values.OPENCODE_MODEL_ID],
+    ];
+    for (const [key, value] of orderedUpdates) {
+        lines = removeEnvKey(lines, key);
+        if (value && value.trim().length > 0) {
+            lines.push(`${key}=${value}`);
+        }
+    }
+    return finalizeEnvContent(lines);
+}
+async function readEnvFileIfExists(filePath) {
+    try {
+        return await fs.readFile(filePath, "utf-8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+async function writeFileAtomically(filePath, content) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const tempFilePath = `${filePath}.${process.pid}.tmp`;
+    await fs.writeFile(tempFilePath, content, "utf-8");
+    await fs.rename(tempFilePath, filePath);
+}
+async function ensureSettingsFile(settingsFilePath) {
+    try {
+        await fs.access(settingsFilePath);
+        return;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    await fs.mkdir(path.dirname(settingsFilePath), { recursive: true });
+    await fs.writeFile(settingsFilePath, "{}\n", "utf-8");
+}
+function getEnvExamplePath() {
+    const currentFilePath = fileURLToPath(import.meta.url);
+    return path.resolve(path.dirname(currentFilePath), "..", "..", ".env.example");
+}
+async function loadModelDefaultsFromEnvExample() {
+    const fallbackDefaults = {
+        provider: FALLBACK_MODEL_PROVIDER,
+        modelId: FALLBACK_MODEL_ID,
+    };
+    try {
+        const content = await fs.readFile(getEnvExamplePath(), "utf-8");
+        const parsed = dotenv.parse(content);
+        const provider = parsed.OPENCODE_MODEL_PROVIDER?.trim();
+        const modelId = parsed.OPENCODE_MODEL_ID?.trim();
+        if (!provider || !modelId) {
+            return fallbackDefaults;
+        }
+        return {
+            provider,
+            modelId,
+        };
+    }
+    catch {
+        return fallbackDefaults;
+    }
+}
+async function askVisible(question) {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const answer = await rl.question(question);
+        return answer.trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+async function askHidden(question) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: true,
+        });
+        const maskedRl = rl;
+        maskedRl._writeToOutput = (value) => {
+            if (maskedRl.stdoutMuted) {
+                if (value.includes("\n") || value.includes("\r")) {
+                    process.stdout.write(value);
+                    return;
+                }
+                if (value.length > 0) {
+                    process.stdout.write("*");
+                }
+                return;
+            }
+            process.stdout.write(value);
+        };
+        maskedRl.stdoutMuted = false;
+        rl.question(question, (answer) => {
+            maskedRl.stdoutMuted = false;
+            process.stdout.write("\n");
+            rl.close();
+            resolve(answer.trim());
+        });
+        maskedRl.stdoutMuted = true;
+    });
+}
+async function askToken() {
+    for (;;) {
+        const token = await askHidden(t("runtime.wizard.ask_token"));
+        if (!token) {
+            process.stdout.write(t("runtime.wizard.token_required"));
+            continue;
+        }
+        if (!token.includes(":")) {
+            process.stdout.write(t("runtime.wizard.token_invalid"));
+            continue;
+        }
+        return token;
+    }
+}
+async function askLocale() {
+    const localeOptions = getLocaleOptions();
+    const defaultLocale = getLocale();
+    const defaultLocaleOption = localeOptions.find((localeOption) => localeOption.code === defaultLocale) ?? localeOptions[0];
+    const optionsText = localeOptions
+        .map((localeOption, index) => `${index + 1} - ${localeOption.label} (${localeOption.code})`)
+        .join("\n");
+    const prompt = t("runtime.wizard.ask_language", {
+        options: optionsText,
+        defaultLocale: `${defaultLocaleOption.label} (${defaultLocaleOption.code})`,
+    });
+    for (;;) {
+        const answer = await askVisible(prompt);
+        if (!answer) {
+            return defaultLocaleOption.code;
+        }
+        if (/^\d+$/.test(answer)) {
+            const index = Number.parseInt(answer, 10) - 1;
+            if (index >= 0 && index < localeOptions.length) {
+                return localeOptions[index].code;
+            }
+        }
+        const localeByCode = resolveSupportedLocale(answer);
+        if (localeByCode) {
+            return localeByCode;
+        }
+        process.stdout.write(t("runtime.wizard.language_invalid"));
+    }
+}
+async function askAllowedUserId() {
+    for (;;) {
+        const allowedUserId = await askVisible(t("runtime.wizard.ask_user_id"));
+        if (!isPositiveInteger(allowedUserId)) {
+            process.stdout.write(t("runtime.wizard.user_id_invalid"));
+            continue;
+        }
+        return allowedUserId;
+    }
+}
+async function askApiUrl() {
+    const prompt = t("runtime.wizard.ask_api_url", { defaultUrl: DEFAULT_API_URL });
+    for (;;) {
+        const apiUrl = await askVisible(prompt);
+        if (!apiUrl) {
+            return undefined;
+        }
+        if (!isValidHttpUrl(apiUrl)) {
+            process.stdout.write(t("runtime.wizard.api_url_invalid"));
+            continue;
+        }
+        return apiUrl;
+    }
+}
+async function askServerUsername() {
+    const prompt = t("runtime.wizard.ask_server_username", {
+        defaultUsername: DEFAULT_SERVER_USERNAME,
+    });
+    const username = await askVisible(prompt);
+    if (!username) {
+        return DEFAULT_SERVER_USERNAME;
+    }
+    return username;
+}
+async function askServerPassword() {
+    const password = await askHidden(t("runtime.wizard.ask_server_password"));
+    if (!password) {
+        return undefined;
+    }
+    return password;
+}
+async function collectWizardValues() {
+    const locale = await askLocale();
+    setRuntimeLocale(locale);
+    const selectedLocaleOption = getLocaleOptions().find((localeOption) => localeOption.code === locale) ?? null;
+    process.stdout.write("\n");
+    process.stdout.write(t("runtime.wizard.language_selected", {
+        language: selectedLocaleOption !== null
+            ? `${selectedLocaleOption.label} (${selectedLocaleOption.code})`
+            : locale,
+    }));
+    process.stdout.write("\n");
+    process.stdout.write(t("runtime.wizard.start"));
+    process.stdout.write("\n");
+    const token = await askToken();
+    const allowedUserId = await askAllowedUserId();
+    const apiUrl = await askApiUrl();
+    const serverUsername = await askServerUsername();
+    const serverPassword = await askServerPassword();
+    process.stdout.write("\n");
+    return {
+        locale,
+        token,
+        allowedUserId,
+        apiUrl,
+        serverUsername,
+        serverPassword,
+    };
+}
+function ensureInteractiveTty() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error(t("runtime.wizard.tty_required"));
+    }
+}
+async function validateExistingEnv(envFilePath) {
+    const content = await readEnvFileIfExists(envFilePath);
+    if (content === null) {
+        return { isValid: false, reason: "Missing .env" };
+    }
+    const parsed = dotenv.parse(content);
+    return validateRuntimeEnvValues(parsed);
+}
+async function runWizardAndPersist(runtimePaths) {
+    ensureInteractiveTty();
+    const [existingContent, modelDefaults, wizardValues] = await Promise.all([
+        readEnvFileIfExists(runtimePaths.envFilePath),
+        loadModelDefaultsFromEnvExample(),
+        collectWizardValues(),
+    ]);
+    const existingParsed = existingContent ? dotenv.parse(existingContent) : {};
+    const provider = existingParsed.OPENCODE_MODEL_PROVIDER || modelDefaults.provider;
+    const modelId = existingParsed.OPENCODE_MODEL_ID || modelDefaults.modelId;
+    const envValues = {
+        BOT_LOCALE: wizardValues.locale,
+        TELEGRAM_BOT_TOKEN: wizardValues.token,
+        TELEGRAM_ALLOWED_USER_ID: wizardValues.allowedUserId,
+        OPENCODE_API_URL: wizardValues.apiUrl,
+        OPENCODE_SERVER_USERNAME: wizardValues.serverUsername,
+        OPENCODE_SERVER_PASSWORD: wizardValues.serverPassword,
+        OPENCODE_MODEL_PROVIDER: provider,
+        OPENCODE_MODEL_ID: modelId,
+    };
+    const envContent = buildEnvFileContent(existingContent ?? "", envValues);
+    await writeFileAtomically(runtimePaths.envFilePath, envContent);
+    await ensureSettingsFile(runtimePaths.settingsFilePath);
+    process.stdout.write(t("runtime.wizard.saved", {
+        envPath: runtimePaths.envFilePath,
+        settingsPath: runtimePaths.settingsFilePath,
+    }));
+}
+export async function ensureRuntimeConfigForStart() {
+    const runtimePaths = getRuntimePaths();
+    if (runtimePaths.mode !== "installed") {
+        return;
+    }
+    const validationResult = await validateExistingEnv(runtimePaths.envFilePath);
+    if (validationResult.isValid) {
+        await ensureSettingsFile(runtimePaths.settingsFilePath);
+        return;
+    }
+    process.stdout.write(t("runtime.wizard.not_configured_starting"));
+    await runWizardAndPersist(runtimePaths);
+}
+export async function runConfigWizardCommand() {
+    const runtimePaths = getRuntimePaths();
+    await runWizardAndPersist(runtimePaths);
+}

package/dist/runtime/mode.js

@@ -0,0 +1,74 @@
+const RUNTIME_MODE_ENV_KEY = "OPENCODE_TELEGRAM_RUNTIME_MODE";
+function normalizeMode(value) {
+    if (value === "installed") {
+        return "installed";
+    }
+    if (value === "sources") {
+        return "sources";
+    }
+    return null;
+}
+function parseModeFromArgv(argv) {
+    let mode = null;
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--mode") {
+            const modeValue = argv[index + 1];
+            if (!modeValue || modeValue.startsWith("-")) {
+                return null;
+            }
+            mode = normalizeMode(modeValue);
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("--mode=")) {
+            mode = normalizeMode(token.slice("--mode=".length));
+        }
+    }
+    return mode;
+}
+function hasInvalidModeSyntax(argv) {
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--mode") {
+            const modeValue = argv[index + 1];
+            if (!modeValue || modeValue.startsWith("-")) {
+                return true;
+            }
+            if (!normalizeMode(modeValue)) {
+                return true;
+            }
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("--mode=")) {
+            const modeValue = token.slice("--mode=".length);
+            if (!normalizeMode(modeValue)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export function resolveRuntimeMode(options) {
+    if (options.explicitMode) {
+        return { mode: options.explicitMode };
+    }
+    const argv = options.argv ?? [];
+    if (hasInvalidModeSyntax(argv)) {
+        return {
+            mode: options.defaultMode,
+            error: "Invalid value for --mode. Expected sources|installed",
+        };
+    }
+    const modeFromArgv = parseModeFromArgv(argv);
+    return { mode: modeFromArgv ?? options.defaultMode };
+}
+export function setRuntimeMode(mode) {
+    process.env[RUNTIME_MODE_ENV_KEY] = mode;
+}
+export function getRuntimeMode() {
+    const rawMode = process.env[RUNTIME_MODE_ENV_KEY];
+    const normalized = rawMode ? normalizeMode(rawMode) : null;
+    return normalized ?? "sources";
+}

package/dist/runtime/paths.js

@@ -0,0 +1,37 @@
+import os from "node:os";
+import path from "node:path";
+import { getRuntimeMode } from "./mode.js";
+const APP_DIR_NAME = "opencode-telegram-group-topics-bot";
+function getInstalledAppHome() {
+    if (process.platform === "win32") {
+        const appData = process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+        return path.join(appData, APP_DIR_NAME);
+    }
+    if (process.platform === "darwin") {
+        return path.join(os.homedir(), "Library", "Application Support", APP_DIR_NAME);
+    }
+    const xdgConfigHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+    return path.join(xdgConfigHome, APP_DIR_NAME);
+}
+function resolveAppHome(mode) {
+    const homeOverride = process.env.OPENCODE_TELEGRAM_HOME;
+    if (homeOverride && homeOverride.trim().length > 0) {
+        return path.resolve(homeOverride);
+    }
+    if (mode === "sources") {
+        return process.cwd();
+    }
+    return getInstalledAppHome();
+}
+export function getRuntimePaths() {
+    const mode = getRuntimeMode();
+    const appHome = resolveAppHome(mode);
+    return {
+        mode,
+        appHome,
+        envFilePath: path.join(appHome, ".env"),
+        settingsFilePath: path.join(appHome, "settings.json"),
+        logsDirPath: path.join(appHome, "logs"),
+        runDirPath: path.join(appHome, "run"),
+    };
+}

package/dist/runtime/process-error-handlers.js

@@ -0,0 +1,24 @@
+import { logger } from "../utils/logger.js";
+const PROCESS_EVENT = {
+    UNHANDLED_REJECTION: "unhandledRejection",
+    UNCAUGHT_EXCEPTION: "uncaughtException",
+};
+let installed = false;
+export function installProcessErrorHandlers() {
+    if (installed) {
+        return;
+    }
+    installed = true;
+    process.on(PROCESS_EVENT.UNHANDLED_REJECTION, (reason) => {
+        logger.error("[Runtime] Unhandled promise rejection", {
+            reason,
+        });
+    });
+    process.on(PROCESS_EVENT.UNCAUGHT_EXCEPTION, (error) => {
+        logger.error("[Runtime] Uncaught exception", {
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+        });
+    });
+}