@nordbyte/nordrelay 0.2.1 → 0.3.1

package/dist/channel-adapter.js

@@ -0,0 +1,58 @@
+const TELEGRAM_CAPABILITIES = [
+    "text",
+    "streaming-edits",
+    "typing",
+    "inline-buttons",
+    "files",
+    "photos",
+    "voice",
+    "topics",
+    "webhooks",
+];
+const PLANNED_CHANNELS = [
+    {
+        id: "discord",
+        label: "Discord",
+        capabilities: ["text", "streaming-edits", "typing", "inline-buttons", "files", "photos", "voice"],
+        status: "planned",
+        notes: "Adapter boundary is ready; runtime integration still needs bot credentials and event mapping.",
+    },
+    {
+        id: "whatsapp",
+        label: "WhatsApp",
+        capabilities: ["text", "typing", "files", "photos", "voice", "webhooks"],
+        status: "planned",
+        notes: "Requires a WhatsApp Business provider integration.",
+    },
+    {
+        id: "slack",
+        label: "Slack",
+        capabilities: ["text", "streaming-edits", "typing", "inline-buttons", "files"],
+        status: "planned",
+    },
+    {
+        id: "matrix",
+        label: "Matrix",
+        capabilities: ["text", "files", "photos", "voice"],
+        status: "planned",
+    },
+];
+export class TelegramChannelAdapter {
+    id = "telegram";
+    label = "Telegram";
+    capabilities = new Set(TELEGRAM_CAPABILITIES);
+    describe() {
+        return {
+            id: this.id,
+            label: this.label,
+            capabilities: [...this.capabilities],
+            status: "available",
+        };
+    }
+}
+export function listChannelDescriptors() {
+    return [
+        new TelegramChannelAdapter().describe(),
+        ...PLANNED_CHANNELS,
+    ];
+}

package/dist/codex-session.js

@@ -47,6 +47,8 @@ export class CodexSessionService {
         const effectiveLaunchProfile = this.activeThreadLaunchProfile ?? this.currentLaunchProfile;
         const codexFastMode = readCodexFastMode();
         this.lastObservedFastMode = codexFastMode;
+        const attachedThreadFastMode = effectiveLaunchProfile.id === "attached-thread" &&
+            effectiveLaunchProfile.approvalPolicy === "never";
         const info = {
             agentId: "codex",
             agentLabel: "Codex",
@@ -58,7 +60,7 @@ export class CodexSessionService {
             launchProfileBehavior: formatLaunchProfileBehavior(effectiveLaunchProfile),
             sandboxMode: effectiveLaunchProfile.sandboxMode,
             approvalPolicy: effectiveLaunchProfile.approvalPolicy,
-            fastMode: codexFastMode ?? (effectiveLaunchProfile.approvalPolicy === "never"),
+            fastMode: attachedThreadFastMode || (codexFastMode ?? (effectiveLaunchProfile.approvalPolicy === "never")),
             unsafeLaunch: effectiveLaunchProfile.unsafe,
             capabilities: CODEX_AGENT_CAPABILITIES,
         };

package/dist/config.js

@@ -24,9 +24,16 @@ export function loadConfig() {
     const telegramNotifyMode = parseNotifyMode(optionalString(process.env.TELEGRAM_NOTIFY_MODE), "minimal");
     const telegramQuietHours = parseQuietHours(optionalString(process.env.TELEGRAM_QUIET_HOURS));
     const telegramRedactPatterns = parseOptionalStringList(optionalString(process.env.TELEGRAM_REDACT_PATTERNS));
+    const telegramTransport = parseTelegramTransport(optionalString(process.env.TELEGRAM_TRANSPORT));
+    const telegramWebhookUrl = optionalString(process.env.TELEGRAM_WEBHOOK_URL);
+    const telegramWebhookHost = optionalString(process.env.TELEGRAM_WEBHOOK_HOST) ?? "127.0.0.1";
+    const telegramWebhookPort = parsePositiveIntegerEnv(optionalString(process.env.TELEGRAM_WEBHOOK_PORT), 8080, "TELEGRAM_WEBHOOK_PORT");
+    const telegramWebhookPath = parseWebhookPath(optionalString(process.env.TELEGRAM_WEBHOOK_PATH));
+    const telegramWebhookSecret = optionalString(process.env.TELEGRAM_WEBHOOK_SECRET);
     const workspace = resolveWorkspace();
     const workspaceAllowedRoots = parsePathList(optionalString(process.env.WORKSPACE_ALLOWED_ROOTS));
     const workspaceWarnRoots = parsePathList(optionalString(process.env.WORKSPACE_WARN_ROOTS));
+    const stateBackend = parseStateBackend(optionalString(process.env.NORDRELAY_STATE_BACKEND));
     const maxFileSize = parseMaxFileSize(optionalString(process.env.MAX_FILE_SIZE));
     const artifactRetentionDays = parsePositiveNumberEnv(optionalString(process.env.ARTIFACT_RETENTION_DAYS), 7, "ARTIFACT_RETENTION_DAYS");
     const artifactMaxTurnDirs = parsePositiveIntegerEnv(optionalString(process.env.ARTIFACT_MAX_TURNS), 30, "ARTIFACT_MAX_TURNS");
@@ -60,6 +67,11 @@ export function loadConfig() {
     const voicePreferredBackend = parseVoiceBackendPreference(optionalString(process.env.VOICE_PREFERRED_BACKEND));
     const voiceDefaultLanguage = optionalString(process.env.VOICE_DEFAULT_LANGUAGE);
     const voiceTranscribeOnly = parseBooleanEnv(optionalString(process.env.VOICE_TRANSCRIBE_ONLY), false);
+    const auditMaxEvents = parsePositiveIntegerEnv(optionalString(process.env.NORDRELAY_AUDIT_MAX_EVENTS), 1000, "NORDRELAY_AUDIT_MAX_EVENTS");
+    const sessionLockTtlMs = parseNonNegativeIntegerEnv(optionalString(process.env.NORDRELAY_SESSION_LOCK_TTL_MS), 30 * 60 * 1000, "NORDRELAY_SESSION_LOCK_TTL_MS");
+    if (telegramTransport === "webhook" && !telegramWebhookUrl) {
+        throw new Error("TELEGRAM_TRANSPORT=webhook requires TELEGRAM_WEBHOOK_URL");
+    }
     return {
         telegramBotToken,
         telegramAllowedUserIds,
@@ -79,9 +91,16 @@ export function loadConfig() {
         telegramNotifyMode,
         telegramQuietHours,
         telegramRedactPatterns,
+        telegramTransport,
+        telegramWebhookUrl,
+        telegramWebhookHost,
+        telegramWebhookPort,
+        telegramWebhookPath,
+        telegramWebhookSecret,
         workspace,
         workspaceAllowedRoots,
         workspaceWarnRoots,
+        stateBackend,
         maxFileSize,
         artifactRetentionDays,
         artifactMaxTurnDirs,
@@ -114,6 +133,8 @@ export function loadConfig() {
         voicePreferredBackend,
         voiceDefaultLanguage,
         voiceTranscribeOnly,
+        auditMaxEvents,
+        sessionLockTtlMs,
     };
 }
 /**
@@ -313,6 +334,32 @@ function parseLogFormat(raw) {
     console.warn(`Invalid CONNECTOR_LOG_FORMAT value: "${raw}". Expected text or json. Falling back to "text".`);
     return "text";
 }
+function parseTelegramTransport(raw) {
+    if (!raw) {
+        return "polling";
+    }
+    if (raw === "polling" || raw === "webhook") {
+        return raw;
+    }
+    console.warn(`Invalid TELEGRAM_TRANSPORT value: "${raw}". Expected polling or webhook. Falling back to polling.`);
+    return "polling";
+}
+function parseWebhookPath(raw) {
+    if (!raw) {
+        return "/telegram/webhook";
+    }
+    return raw.startsWith("/") ? raw : `/${raw}`;
+}
+function parseStateBackend(raw) {
+    if (!raw) {
+        return "json";
+    }
+    if (raw === "json" || raw === "sqlite") {
+        return raw;
+    }
+    console.warn(`Invalid NORDRELAY_STATE_BACKEND value: "${raw}". Expected json or sqlite. Falling back to json.`);
+    return "json";
+}
 function parseLaunchProfiles(raw, codexSandboxMode, codexApprovalPolicy, enableUnsafeLaunchProfiles) {
     const defaultProfile = createDefaultLaunchProfile(codexSandboxMode, codexApprovalPolicy);
     const profiles = createBuiltinLaunchProfiles(defaultProfile, {

package/dist/context-key.js

@@ -21,3 +21,26 @@ export function parseContextKey(key) {
 export function isTopicContextKey(key) {
     return key.includes(":");
 }
+export function isTelegramContextKey(key) {
+    const parts = key.split(":");
+    if (parts.length < 1 || parts.length > 2) {
+        return false;
+    }
+    const chatIdText = parts[0];
+    if (!chatIdText || !/^-?\d+$/.test(chatIdText)) {
+        return false;
+    }
+    const chatId = Number(chatIdText);
+    if (!Number.isSafeInteger(chatId) || chatId === 0) {
+        return false;
+    }
+    const threadIdText = parts[1];
+    if (threadIdText === undefined) {
+        return true;
+    }
+    if (!/^\d+$/.test(threadIdText)) {
+        return false;
+    }
+    const threadId = Number(threadIdText);
+    return Number.isSafeInteger(threadId) && threadId > 0;
+}

package/dist/index.js

@@ -1,5 +1,7 @@
+import { createServer } from "node:http";
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { webhookCallback } from "grammy";
 import { createBot, registerCommands } from "./bot.js";
 import { checkAuthStatus } from "./codex-auth.js";
 import { describeCodexCli, resolveCodexCli } from "./codex-cli.js";
@@ -12,8 +14,11 @@ import { configureRedaction } from "./redaction.js";
 import { SessionRegistry } from "./session-registry.js";
 let registry;
 let bot;
+let webhookServer;
+let runtimeConfig;
 try {
     const config = loadConfig();
+    runtimeConfig = config;
     configureRedaction(config.telegramRedactPatterns);
     installConsoleLogger(config.logFormat);
     registry = new SessionRegistry(config);
@@ -46,6 +51,7 @@ try {
         }
     }
     console.log("Session mode: per Telegram context");
+    console.log(`Telegram transport: ${config.telegramTransport}`);
     await writeConnectorState({
         status: "ready",
         pid: Number(process.env.NORDRELAY_WRAPPER_PID) || process.pid,
@@ -56,6 +62,7 @@ try {
         authMethod: authStatus.method,
         codexCli: describeCodexCli(codexCli),
         piCli: describePiCli(piCli),
+        telegramTransport: config.telegramTransport,
     });
 }
 catch (error) {
@@ -77,8 +84,9 @@ const shutdown = (signal) => {
     }
     shuttingDown = true;
     console.log(`Received ${signal}, shutting down NordRelay...`);
-    if (bot)
+    if (bot && runtimeConfig?.telegramTransport !== "webhook")
         bot.stop();
+    webhookServer?.close();
     setTimeout(() => {
         registry?.disposeAll();
         void writeConnectorState({
@@ -124,7 +132,44 @@ async function startPolling() {
         process.exit(1);
     }
 }
-await startPolling();
+if (registry && bot) {
+    if (runtimeConfig?.telegramTransport === "webhook") {
+        webhookServer = await startWebhook(bot, runtimeConfig);
+    }
+    else {
+        await startPolling();
+    }
+}
+async function startWebhook(activeBot, config) {
+    const callback = webhookCallback(activeBot, "http", {
+        secretToken: config.telegramWebhookSecret,
+    });
+    const server = createServer((req, res) => {
+        if (req.method === "GET" && req.url === "/healthz") {
+            res.writeHead(200, { "content-type": "text/plain" });
+            res.end("ok\n");
+            return;
+        }
+        if (req.url?.split("?")[0] !== config.telegramWebhookPath) {
+            res.writeHead(404, { "content-type": "text/plain" });
+            res.end("not found\n");
+            return;
+        }
+        void callback(req, res);
+    });
+    await activeBot.api.setWebhook(joinWebhookUrl(config.telegramWebhookUrl, config.telegramWebhookPath), {
+        secret_token: config.telegramWebhookSecret,
+        drop_pending_updates: process.env.NORDRELAY_DROP_PENDING_UPDATES !== "0",
+    });
+    await new Promise((resolve) => {
+        server.listen(config.telegramWebhookPort, config.telegramWebhookHost, resolve);
+    });
+    console.log(`Webhook listening on ${config.telegramWebhookHost}:${config.telegramWebhookPort}${config.telegramWebhookPath}`);
+    return server;
+}
+function joinWebhookUrl(baseUrl, webhookPath) {
+    return `${baseUrl.replace(/\/+$/, "")}${webhookPath.startsWith("/") ? webhookPath : `/${webhookPath}`}`;
+}
 async function writeConnectorState(payload) {
     const stateFile = process.env.NORDRELAY_STATE_FILE;
     if (!stateFile) {

package/dist/logger.js

@@ -1,9 +1,20 @@
 import { redactUnknown } from "./redaction.js";
 export function installConsoleLogger(format) {
+    const targetLog = console.log.bind(console);
+    const targetWarn = console.warn.bind(console);
+    const targetError = console.error.bind(console);
     if (format !== "json") {
+        console.log = (...args) => {
+            targetLog(toTextRecord("info", args));
+        };
+        console.warn = (...args) => {
+            targetWarn(toTextRecord("warn", args));
+        };
+        console.error = (...args) => {
+            targetError(toTextRecord("error", args));
+        };
         return;
     }
-    const targetLog = console.log.bind(console);
     console.log = (...args) => {
         targetLog(JSON.stringify(toLogRecord("info", args)));
     };
@@ -14,6 +25,9 @@ export function installConsoleLogger(format) {
         targetLog(JSON.stringify(toLogRecord("error", args)));
     };
 }
+function toTextRecord(level, args) {
+    return `[${formatLocalTimestamp(new Date())}] ${level.toUpperCase()} ${args.map(formatArg).join(" ")}`;
+}
 function toLogRecord(level, args) {
     return {
         ts: new Date().toISOString(),
@@ -25,3 +39,12 @@ function toLogRecord(level, args) {
 function formatArg(value) {
     return redactUnknown(value);
 }
+function formatLocalTimestamp(date) {
+    return [
+        `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`,
+        `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`,
+    ].join(" ");
+}
+function pad(value) {
+    return String(value).padStart(2, "0");
+}