@nordbyte/nordrelay 0.2.1

package/dist/session-format.js

@@ -0,0 +1,191 @@
+import { CODEX_AGENT_CAPABILITIES, agentReasoningLabel } from "./agent.js";
+import { escapeHTML } from "./format.js";
+export function renderSessionInfoPlain(info) {
+    const capabilities = info.capabilities ?? CODEX_AGENT_CAPABILITIES;
+    const agentId = info.agentId ?? "codex";
+    return [
+        `Agent: ${info.agentLabel ?? "Codex"}`,
+        `Thread ID: ${info.threadId ?? "(not started yet)"}`,
+        `Workspace: ${info.workspace}`,
+        capabilities.launchProfiles
+            ? `Launch profile: ${info.launchProfileLabel} (${info.launchProfileBehavior})${info.unsafeLaunch ? " [unsafe]" : ""}`
+            : `Mode: ${info.launchProfileLabel} (${info.launchProfileBehavior})`,
+        info.nextLaunchProfileId
+            ? `Next launch profile: ${info.nextLaunchProfileLabel} (${info.nextLaunchProfileBehavior})${info.nextUnsafeLaunch ? " [unsafe]" : ""}`
+            : undefined,
+        `Model: ${info.model ?? "(default)"}`,
+        capabilities.fastMode
+            ? `Reasoning/Fast: ${info.reasoningEffort ?? "(model default)"} / ${info.fastMode ? "on" : "off"}`
+            : `${agentReasoningLabel(agentId)}: ${info.reasoningEffort ?? "(model default)"}`,
+        ...renderCodexUsagePlain(info),
+        ...renderAgentUsagePlain(info),
+        info.sessionTokens ? formatSessionTokensPlain(info.sessionTokens) : undefined,
+    ]
+        .filter((line) => Boolean(line))
+        .join("\n");
+}
+export function renderSessionInfoHTML(info) {
+    const capabilities = info.capabilities ?? CODEX_AGENT_CAPABILITIES;
+    const agentId = info.agentId ?? "codex";
+    return [
+        `<b>Agent:</b> <code>${escapeHTML(info.agentLabel ?? "Codex")}</code>`,
+        `<b>Thread ID:</b> <code>${escapeHTML(info.threadId ?? "(not started yet)")}</code>`,
+        `<b>Workspace:</b> <code>${escapeHTML(info.workspace)}</code>`,
+        capabilities.launchProfiles
+            ? `<b>Launch profile:</b> <code>${escapeHTML(info.launchProfileLabel)}</code>`
+            : `<b>Mode:</b> <code>${escapeHTML(info.launchProfileLabel)}</code>`,
+        `<b>Launch behavior:</b> <code>${escapeHTML(info.launchProfileBehavior)}</code>${info.unsafeLaunch ? " ⚠️" : ""}`,
+        info.nextLaunchProfileId
+            ? `<b>Next launch profile:</b> <code>${escapeHTML(info.nextLaunchProfileLabel ?? "")}</code> <i>(${escapeHTML(info.nextLaunchProfileBehavior ?? "")})</i>${info.nextUnsafeLaunch ? " ⚠️" : ""}`
+            : undefined,
+        `<b>Model:</b> <code>${escapeHTML(info.model ?? "(default)")}</code>`,
+        capabilities.fastMode
+            ? `<b>Reasoning/Fast:</b> <code>${escapeHTML(info.reasoningEffort ?? "(model default)")} / ${info.fastMode ? "on" : "off"}</code>`
+            : `<b>${escapeHTML(agentReasoningLabel(agentId))}:</b> <code>${escapeHTML(info.reasoningEffort ?? "(model default)")}</code>`,
+        ...renderCodexUsageHTML(info),
+        ...renderAgentUsageHTML(info),
+        info.sessionTokens ? `<b>Session tokens:</b> <code>${escapeHTML(formatSessionTokensValue(info.sessionTokens))}</code>` : undefined,
+    ]
+        .filter((line) => Boolean(line))
+        .join("\n");
+}
+export function renderLaunchSummaryPlain(info) {
+    const capabilities = info.capabilities ?? CODEX_AGENT_CAPABILITIES;
+    return `${capabilities.launchProfiles ? "Launch" : "Mode"}: ${info.launchProfileLabel} (${info.launchProfileBehavior})${info.unsafeLaunch ? " [unsafe]" : ""}`;
+}
+export function renderLaunchSummaryHTML(info) {
+    const suffix = info.unsafeLaunch ? " ⚠️" : "";
+    const capabilities = info.capabilities ?? CODEX_AGENT_CAPABILITIES;
+    return `<b>${capabilities.launchProfiles ? "Launch" : "Mode"}:</b> <code>${escapeHTML(info.launchProfileLabel)}</code> <i>(${escapeHTML(info.launchProfileBehavior)})</i>${suffix}`;
+}
+export function formatFileSize(bytes) {
+    if (bytes < 1024) {
+        return `${bytes} B`;
+    }
+    if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(1).replace(/\.0$/, "")} KB`;
+    }
+    return `${(bytes / (1024 * 1024)).toFixed(1).replace(/\.0$/, "")} MB`;
+}
+function renderCodexUsagePlain(info) {
+    const usage = info.codexUsage;
+    if (!usage) {
+        return [];
+    }
+    const lines = [];
+    if (usage.contextUsedPercent !== null && usage.contextWindow !== null && usage.lastTokenUsage) {
+        lines.push(`Context used: ${formatPercent(usage.contextUsedPercent)} (${formatCompactTokenCount(usage.lastTokenUsage.totalTokens)} / ${formatCompactTokenCount(usage.contextWindow)})`);
+    }
+    if (usage.totalTokenUsage) {
+        lines.push([
+            `Tokens in: ${formatCompactTokenCount(usage.totalTokenUsage.inputTokens)}`,
+            `cached: ${formatCompactTokenCount(usage.totalTokenUsage.cachedInputTokens)}`,
+            `out: ${formatCompactTokenCount(usage.totalTokenUsage.outputTokens)}`,
+            `reasoning out: ${formatCompactTokenCount(usage.totalTokenUsage.reasoningOutputTokens)}`,
+        ].join(" · "));
+    }
+    const limits = formatLimitsLeft(usage);
+    if (limits) {
+        lines.push(`Limits left: ${limits}`);
+    }
+    return lines;
+}
+function renderCodexUsageHTML(info) {
+    const usage = info.codexUsage;
+    if (!usage) {
+        return [];
+    }
+    const lines = [];
+    if (usage.contextUsedPercent !== null && usage.contextWindow !== null && usage.lastTokenUsage) {
+        lines.push(`<b>Context used:</b> <code>${escapeHTML(formatPercent(usage.contextUsedPercent))}</code> <i>(${escapeHTML(formatCompactTokenCount(usage.lastTokenUsage.totalTokens))} / ${escapeHTML(formatCompactTokenCount(usage.contextWindow))})</i>`);
+    }
+    if (usage.totalTokenUsage) {
+        lines.push(`<b>Tokens:</b> <code>${escapeHTML([
+            `in ${formatCompactTokenCount(usage.totalTokenUsage.inputTokens)}`,
+            `cached ${formatCompactTokenCount(usage.totalTokenUsage.cachedInputTokens)}`,
+            `out ${formatCompactTokenCount(usage.totalTokenUsage.outputTokens)}`,
+            `reasoning out ${formatCompactTokenCount(usage.totalTokenUsage.reasoningOutputTokens)}`,
+        ].join(" · "))}</code>`);
+    }
+    const limits = formatLimitsLeft(usage);
+    if (limits) {
+        lines.push(`<b>Limits left:</b> <code>${escapeHTML(limits)}</code>`);
+    }
+    return lines;
+}
+function renderAgentUsagePlain(info) {
+    const lines = [];
+    if (info.contextUsage?.percent !== undefined && info.contextUsage.percent !== null) {
+        const contextWindow = info.contextUsage.contextWindow !== null && info.contextUsage.contextWindow !== undefined
+            ? ` (${formatCompactTokenCount(info.contextUsage.tokens ?? 0)} / ${formatCompactTokenCount(info.contextUsage.contextWindow)})`
+            : "";
+        lines.push(`Context used: ${formatPercent(info.contextUsage.percent)}${contextWindow}`);
+    }
+    if (info.sessionUsage) {
+        lines.push([
+            `Tokens in: ${formatCompactTokenCount(info.sessionUsage.input)}`,
+            `cache read: ${formatCompactTokenCount(info.sessionUsage.cacheRead)}`,
+            `cache write: ${formatCompactTokenCount(info.sessionUsage.cacheWrite)}`,
+            `out: ${formatCompactTokenCount(info.sessionUsage.output)}`,
+        ].join(" · "));
+    }
+    return lines;
+}
+function renderAgentUsageHTML(info) {
+    const lines = [];
+    if (info.contextUsage?.percent !== undefined && info.contextUsage.percent !== null) {
+        const contextWindow = info.contextUsage.contextWindow !== null && info.contextUsage.contextWindow !== undefined
+            ? ` <i>(${escapeHTML(formatCompactTokenCount(info.contextUsage.tokens ?? 0))} / ${escapeHTML(formatCompactTokenCount(info.contextUsage.contextWindow))})</i>`
+            : "";
+        lines.push(`<b>Context used:</b> <code>${escapeHTML(formatPercent(info.contextUsage.percent))}</code>${contextWindow}`);
+    }
+    if (info.sessionUsage) {
+        lines.push(`<b>Tokens:</b> <code>${escapeHTML([
+            `in ${formatCompactTokenCount(info.sessionUsage.input)}`,
+            `cache read ${formatCompactTokenCount(info.sessionUsage.cacheRead)}`,
+            `cache write ${formatCompactTokenCount(info.sessionUsage.cacheWrite)}`,
+            `out ${formatCompactTokenCount(info.sessionUsage.output)}`,
+        ].join(" · "))}</code>`);
+    }
+    return lines;
+}
+function formatLimitsLeft(usage) {
+    const parts = [];
+    if (usage.rateLimits?.primary) {
+        parts.push(`5h ${formatPercent(usage.rateLimits.primary.remainingPercent)}`);
+    }
+    if (usage.rateLimits?.secondary) {
+        parts.push(`weekly ${formatPercent(usage.rateLimits.secondary.remainingPercent)}`);
+    }
+    return parts.join(" · ");
+}
+function formatCompactTokenCount(value) {
+    const abs = Math.abs(value);
+    const units = [
+        { threshold: 1_000_000_000_000, suffix: "T" },
+        { threshold: 1_000_000_000, suffix: "B" },
+        { threshold: 1_000_000, suffix: "M" },
+        { threshold: 1_000, suffix: "K" },
+    ];
+    const unit = units.find((candidate) => abs >= candidate.threshold);
+    if (!unit) {
+        return Math.round(value).toLocaleString("en-US");
+    }
+    const scaled = value / unit.threshold;
+    const decimals = Math.abs(scaled) < 100 ? 1 : 0;
+    return `${scaled.toFixed(decimals).replace(/\.0$/, "")}${unit.suffix}`;
+}
+function formatPercent(value) {
+    const rounded = Math.round(value * 10) / 10;
+    return `${Number.isInteger(rounded) ? rounded.toFixed(0) : rounded.toFixed(1)}%`;
+}
+function formatSessionTokensValue(tokens) {
+    return [
+        `in: ${formatCompactTokenCount(tokens.input)}`,
+        `cached: ${formatCompactTokenCount(tokens.cached)}`,
+        `out: ${formatCompactTokenCount(tokens.output)}`,
+    ].join(" · ");
+}
+function formatSessionTokensPlain(tokens) {
+    return `Session tokens: ${formatSessionTokensValue(tokens)}`;
+}

package/dist/session-registry.js

@@ -0,0 +1,195 @@
+import path from "node:path";
+import { createAgentSessionService } from "./agent-factory.js";
+import { CODEX_AGENT_CAPABILITIES } from "./agent.js";
+import { findLaunchProfile } from "./codex-launch.js";
+import { readJsonFileWithBackup, writeJsonFileAtomic } from "./persistence.js";
+export class SessionRegistry {
+    config;
+    sessions = new Map();
+    metadata = new Map();
+    persistPath;
+    onRemoveCallback;
+    constructor(config) {
+        this.config = config;
+        this.persistPath = path.join(config.workspace, ".nordrelay", "contexts.json");
+        this.loadPersistedMetadata();
+    }
+    async getOrCreate(contextKey, options) {
+        let session = this.sessions.get(contextKey);
+        if (session && (!options?.agentId || session.getInfo().agentId === options.agentId)) {
+            return session;
+        }
+        if (session && options?.agentId && session.getInfo().agentId !== options.agentId) {
+            session.dispose();
+            this.sessions.delete(contextKey);
+        }
+        const meta = this.metadata.get(contextKey);
+        const agentId = options?.agentId ?? meta?.agentId ?? this.config.defaultAgent ?? "codex";
+        const launchProfileId = resolveLaunchProfileId(this.config, meta);
+        session = await createAgentSessionService(this.config, agentId, {
+            workspace: meta?.workspace,
+            model: meta?.model,
+            reasoningEffort: meta?.reasoningEffort,
+            launchProfileId,
+            deferThreadStart: options?.deferThreadStart && !meta?.threadId,
+            resumeThreadId: meta?.threadId ?? undefined,
+            sessionPath: meta?.sessionPath,
+        });
+        this.sessions.set(contextKey, session);
+        return session;
+    }
+    get(contextKey) {
+        return this.sessions.get(contextKey);
+    }
+    has(contextKey) {
+        return this.sessions.has(contextKey);
+    }
+    hasMetadata(contextKey) {
+        return this.metadata.has(contextKey);
+    }
+    async switchAgent(contextKey, agentId) {
+        const current = this.sessions.get(contextKey);
+        if (current?.getInfo().agentId === agentId) {
+            return current;
+        }
+        current?.dispose();
+        this.sessions.delete(contextKey);
+        const previous = this.metadata.get(contextKey);
+        const next = {
+            contextKey,
+            agentId,
+            threadId: null,
+            workspace: previous?.workspace ?? this.config.workspace,
+            pinnedThreadIds: previous?.pinnedThreadIds,
+            updatedAt: Date.now(),
+        };
+        this.metadata.set(contextKey, next);
+        this.persistMetadata();
+        return this.getOrCreate(contextKey, { deferThreadStart: true, agentId });
+    }
+    updateMetadata(contextKey, session) {
+        const info = session.getInfo();
+        const previous = this.metadata.get(contextKey);
+        const pinnedThreadIds = previous?.pinnedThreadIds ?? [];
+        const next = {
+            contextKey,
+            threadId: info.threadId,
+            workspace: info.workspace,
+            model: info.model,
+            reasoningEffort: info.reasoningEffort,
+            launchProfileId: info.nextLaunchProfileId ?? info.launchProfileId,
+            updatedAt: Date.now(),
+        };
+        if (info.agentId && info.agentId !== "codex") {
+            next.agentId = info.agentId;
+        }
+        if (info.sessionPath) {
+            next.sessionPath = info.sessionPath;
+        }
+        if (pinnedThreadIds.length > 0) {
+            next.pinnedThreadIds = pinnedThreadIds;
+        }
+        this.metadata.set(contextKey, next);
+        this.persistMetadata();
+    }
+    pinThread(contextKey, threadId) {
+        const meta = this.metadata.get(contextKey) ?? this.createEmptyMetadata(contextKey);
+        const pinned = new Set(meta.pinnedThreadIds ?? []);
+        pinned.add(threadId);
+        meta.pinnedThreadIds = [...pinned];
+        meta.updatedAt = Date.now();
+        this.metadata.set(contextKey, meta);
+        this.persistMetadata();
+        return meta.pinnedThreadIds;
+    }
+    unpinThread(contextKey, threadId) {
+        const meta = this.metadata.get(contextKey) ?? this.createEmptyMetadata(contextKey);
+        meta.pinnedThreadIds = (meta.pinnedThreadIds ?? []).filter((id) => id !== threadId);
+        meta.updatedAt = Date.now();
+        this.metadata.set(contextKey, meta);
+        this.persistMetadata();
+        return meta.pinnedThreadIds;
+    }
+    listPinnedThreadIds(contextKey) {
+        return [...(this.metadata.get(contextKey)?.pinnedThreadIds ?? [])];
+    }
+    listContexts() {
+        return [...this.metadata.values()].sort((left, right) => right.updatedAt - left.updatedAt);
+    }
+    syncAllFromCodexState(options = {}) {
+        const results = [];
+        for (const [contextKey, session] of this.sessions.entries()) {
+            if (!(session.getInfo().capabilities ?? CODEX_AGENT_CAPABILITIES).externalActivity) {
+                continue;
+            }
+            const result = session.syncFromCodexState(options);
+            if (result.changed) {
+                this.updateMetadata(contextKey, session);
+            }
+            results.push({ contextKey, result });
+        }
+        return results;
+    }
+    onRemove(callback) {
+        this.onRemoveCallback = callback;
+    }
+    remove(contextKey) {
+        const session = this.sessions.get(contextKey);
+        session?.dispose();
+        this.sessions.delete(contextKey);
+        this.metadata.delete(contextKey);
+        this.onRemoveCallback?.(contextKey);
+        this.persistMetadata();
+    }
+    disposeAll() {
+        for (const session of this.sessions.values()) {
+            session.dispose();
+        }
+        this.sessions.clear();
+    }
+    persistMetadata() {
+        try {
+            const data = [...this.metadata.values()];
+            writeJsonFileAtomic(this.persistPath, data);
+        }
+        catch (error) {
+            console.warn("Failed to persist context metadata:", error instanceof Error ? error.message : String(error));
+        }
+    }
+    loadPersistedMetadata() {
+        try {
+            const data = readJsonFileWithBackup(this.persistPath).value;
+            if (!Array.isArray(data)) {
+                return;
+            }
+            for (const entry of data) {
+                if (entry.contextKey) {
+                    this.metadata.set(entry.contextKey, entry);
+                }
+            }
+        }
+        catch {
+            // Silently ignore load errors.
+        }
+    }
+    createEmptyMetadata(contextKey) {
+        return {
+            contextKey,
+            threadId: null,
+            workspace: this.config.workspace,
+            launchProfileId: this.config.defaultLaunchProfileId,
+            pinnedThreadIds: [],
+            updatedAt: Date.now(),
+        };
+    }
+}
+function resolveLaunchProfileId(config, meta) {
+    if (!meta?.launchProfileId) {
+        return undefined;
+    }
+    if (findLaunchProfile(config.launchProfiles, meta.launchProfileId)) {
+        return meta.launchProfileId;
+    }
+    console.warn(`Unknown persisted launch profile "${meta.launchProfileId}" for ${meta.contextKey}. Falling back to ${config.defaultLaunchProfileId}.`);
+    return undefined;
+}

package/dist/telegram-rate-limit.js

@@ -0,0 +1,136 @@
+const DEFAULT_OPTIONS = {
+    minIntervalMs: 80,
+    editMinIntervalMs: 1200,
+    maxRetries: 5,
+};
+export class TelegramRateLimiter {
+    options;
+    buckets = new Map();
+    queued = 0;
+    running = 0;
+    completed = 0;
+    failed = 0;
+    retries = 0;
+    rateLimitHits = 0;
+    lastRateLimitAt;
+    lastRetryAfterSeconds;
+    constructor(options = DEFAULT_OPTIONS) {
+        this.options = options;
+    }
+    configure(options) {
+        this.options = { ...this.options, ...options };
+    }
+    async run(bucket, method, operation) {
+        const normalizedBucket = `${method}:${bucket}`;
+        const state = this.getBucket(normalizedBucket);
+        this.queued += 1;
+        let releasePrevious;
+        const previous = state.chain;
+        state.chain = new Promise((resolve) => {
+            releasePrevious = resolve;
+        });
+        await previous.catch(() => { });
+        this.queued = Math.max(0, this.queued - 1);
+        this.running += 1;
+        try {
+            await this.waitForBucket(state, method);
+            const result = await this.runWithRetries(operation);
+            this.completed += 1;
+            state.lastRunAtMs = Date.now();
+            state.queuedUntilMs = Math.max(state.queuedUntilMs, state.lastRunAtMs + this.intervalForMethod(method));
+            return result;
+        }
+        catch (error) {
+            this.failed += 1;
+            throw error;
+        }
+        finally {
+            this.running = Math.max(0, this.running - 1);
+            releasePrevious();
+        }
+    }
+    getMetrics() {
+        return {
+            queued: this.queued,
+            running: this.running,
+            completed: this.completed,
+            failed: this.failed,
+            retries: this.retries,
+            rateLimitHits: this.rateLimitHits,
+            lastRateLimitAt: this.lastRateLimitAt,
+            lastRetryAfterSeconds: this.lastRetryAfterSeconds,
+            buckets: [...this.buckets.entries()]
+                .filter(([, state]) => state.queuedUntilMs > Date.now() || state.lastRunAtMs > 0)
+                .slice(0, 12)
+                .map(([bucket, state]) => ({
+                bucket,
+                queuedUntilMs: state.queuedUntilMs,
+                lastRunAtMs: state.lastRunAtMs,
+            })),
+        };
+    }
+    getBucket(bucket) {
+        let state = this.buckets.get(bucket);
+        if (!state) {
+            state = {
+                chain: Promise.resolve(),
+                queuedUntilMs: 0,
+                lastRunAtMs: 0,
+            };
+            this.buckets.set(bucket, state);
+        }
+        return state;
+    }
+    async waitForBucket(state, method) {
+        const interval = this.intervalForMethod(method);
+        const now = Date.now();
+        const earliest = Math.max(state.queuedUntilMs, state.lastRunAtMs + interval);
+        if (earliest > now) {
+            await delay(earliest - now);
+        }
+    }
+    async runWithRetries(operation) {
+        let attempt = 0;
+        while (true) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                const retryAfterSeconds = getRetryAfterSeconds(error);
+                if (retryAfterSeconds === undefined || attempt >= this.options.maxRetries) {
+                    throw error;
+                }
+                attempt += 1;
+                this.retries += 1;
+                this.rateLimitHits += 1;
+                this.lastRateLimitAt = new Date().toISOString();
+                this.lastRetryAfterSeconds = retryAfterSeconds;
+                await delay((retryAfterSeconds * 1000) + 250);
+            }
+        }
+    }
+    intervalForMethod(method) {
+        return method.startsWith("edit") ? this.options.editMinIntervalMs : this.options.minIntervalMs;
+    }
+}
+export const telegramRateLimiter = new TelegramRateLimiter();
+export function getTelegramRateLimitMetrics() {
+    return telegramRateLimiter.getMetrics();
+}
+function getRetryAfterSeconds(error) {
+    const candidate = error;
+    const direct = candidate.parameters?.retry_after ?? candidate.error?.parameters?.retry_after;
+    if (typeof direct === "number" && Number.isFinite(direct)) {
+        return Math.max(1, direct);
+    }
+    const text = `${typeof candidate.description === "string" ? candidate.description : ""} ${typeof candidate.message === "string" ? candidate.message : ""}`;
+    const match = text.match(/retry after\s+(\d+)/i);
+    if (!match) {
+        return undefined;
+    }
+    const parsed = Number(match[1]);
+    return Number.isFinite(parsed) ? Math.max(1, parsed) : undefined;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+}