@nordbyte/nordrelay 0.2.1

package/dist/index.js

@@ -0,0 +1,140 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { createBot, registerCommands } from "./bot.js";
+import { checkAuthStatus } from "./codex-auth.js";
+import { describeCodexCli, resolveCodexCli } from "./codex-cli.js";
+import { findLaunchProfile, formatLaunchProfileBehavior } from "./codex-launch.js";
+import { enabledAgents } from "./agent-factory.js";
+import { loadConfig } from "./config.js";
+import { installConsoleLogger } from "./logger.js";
+import { describePiCli, resolvePiCli } from "./pi-cli.js";
+import { configureRedaction } from "./redaction.js";
+import { SessionRegistry } from "./session-registry.js";
+let registry;
+let bot;
+try {
+    const config = loadConfig();
+    configureRedaction(config.telegramRedactPatterns);
+    installConsoleLogger(config.logFormat);
+    registry = new SessionRegistry(config);
+    bot = createBot(config, registry);
+    await registerCommands(bot);
+    console.log("NordRelay running");
+    const authStatus = config.codexEnabled
+        ? await checkAuthStatus(config.codexApiKey)
+        : { authenticated: true, method: "codex-disabled" };
+    if (config.codexEnabled) {
+        console.log(`Auth: ${authStatus.authenticated ? "authenticated" : "not authenticated"} (${authStatus.method})`);
+        if (!authStatus.authenticated) {
+            console.warn("Warning: Codex is not authenticated. Use /login or set CODEX_API_KEY.");
+        }
+    }
+    console.log(`Workspace: ${config.workspace}`);
+    console.log(`Enabled agents: ${enabledAgents(config).join(", ")} (default: ${config.defaultAgent})`);
+    if (config.codexModel) {
+        console.log(`Default model: ${config.codexModel}`);
+    }
+    const codexCli = resolveCodexCli();
+    const piCli = resolvePiCli(process.env, config.piCliPath);
+    console.log(`Codex CLI: ${describeCodexCli(codexCli)}`);
+    console.log(`Pi CLI: ${describePiCli(piCli)}`);
+    const defaultLaunchProfile = findLaunchProfile(config.launchProfiles, config.defaultLaunchProfileId);
+    if (defaultLaunchProfile) {
+        console.log(`Default launch profile: ${defaultLaunchProfile.label} (${formatLaunchProfileBehavior(defaultLaunchProfile)})`);
+        if (defaultLaunchProfile.unsafe) {
+            console.warn("Warning: Default launch profile uses danger-full-access.");
+        }
+    }
+    console.log("Session mode: per Telegram context");
+    await writeConnectorState({
+        status: "ready",
+        pid: Number(process.env.NORDRELAY_WRAPPER_PID) || process.pid,
+        appPid: process.pid,
+        workspace: config.workspace,
+        sessionMode: "per Telegram context",
+        authenticated: authStatus.authenticated,
+        authMethod: authStatus.method,
+        codexCli: describeCodexCli(codexCli),
+        piCli: describePiCli(piCli),
+    });
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Failed to start NordRelay: ${message}`);
+    await writeConnectorState({
+        status: "error",
+        pid: Number(process.env.NORDRELAY_WRAPPER_PID) || process.pid,
+        appPid: process.pid,
+        error: message,
+    });
+    registry?.disposeAll();
+    process.exit(1);
+}
+let shuttingDown = false;
+const shutdown = (signal) => {
+    if (shuttingDown) {
+        return;
+    }
+    shuttingDown = true;
+    console.log(`Received ${signal}, shutting down NordRelay...`);
+    if (bot)
+        bot.stop();
+    setTimeout(() => {
+        registry?.disposeAll();
+        void writeConnectorState({
+            status: "stopped",
+            pid: Number(process.env.NORDRELAY_WRAPPER_PID) || process.pid,
+            appPid: process.pid,
+            signal,
+        }).finally(() => {
+            console.log("NordRelay stopped.");
+            process.exit(0);
+        });
+    }, 500);
+};
+process.once("SIGINT", () => shutdown("SIGINT"));
+process.once("SIGTERM", () => shutdown("SIGTERM"));
+const MAX_RESTART_ATTEMPTS = 5;
+const RESTART_DELAY_MS = 3000;
+let restartAttempts = 0;
+async function startPolling() {
+    try {
+        await bot.start({
+            drop_pending_updates: process.env.NORDRELAY_DROP_PENDING_UPDATES !== "0",
+            onStart: () => {
+                restartAttempts = 0;
+            },
+        });
+    }
+    catch (error) {
+        if (shuttingDown) {
+            return;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        const is409 = message.includes("409") || message.includes("Conflict");
+        if (is409 && restartAttempts < MAX_RESTART_ATTEMPTS) {
+            restartAttempts += 1;
+            console.warn(`Polling error (attempt ${restartAttempts}/${MAX_RESTART_ATTEMPTS}): ${message}`);
+            console.warn(`Restarting polling in ${RESTART_DELAY_MS / 1000}s...`);
+            await new Promise((resolve) => setTimeout(resolve, RESTART_DELAY_MS));
+            return startPolling();
+        }
+        console.error(`Fatal polling error: ${message}`);
+        registry?.disposeAll();
+        process.exit(1);
+    }
+}
+await startPolling();
+async function writeConnectorState(payload) {
+    const stateFile = process.env.NORDRELAY_STATE_FILE;
+    if (!stateFile) {
+        return;
+    }
+    try {
+        await mkdir(path.dirname(stateFile), { recursive: true });
+        await writeFile(stateFile, `${JSON.stringify({ ...payload, updatedAt: new Date().toISOString() }, null, 2)}\n`, "utf8");
+    }
+    catch (error) {
+        console.warn("Failed to write connector state:", error instanceof Error ? error.message : String(error));
+    }
+}

package/dist/logger.js

@@ -0,0 +1,27 @@
+import { redactUnknown } from "./redaction.js";
+export function installConsoleLogger(format) {
+    if (format !== "json") {
+        return;
+    }
+    const targetLog = console.log.bind(console);
+    console.log = (...args) => {
+        targetLog(JSON.stringify(toLogRecord("info", args)));
+    };
+    console.warn = (...args) => {
+        targetLog(JSON.stringify(toLogRecord("warn", args)));
+    };
+    console.error = (...args) => {
+        targetLog(JSON.stringify(toLogRecord("error", args)));
+    };
+}
+function toLogRecord(level, args) {
+    return {
+        ts: new Date().toISOString(),
+        level,
+        event: "console",
+        message: args.map(formatArg).join(" "),
+    };
+}
+function formatArg(value) {
+    return redactUnknown(value);
+}

package/dist/operations.js

@@ -0,0 +1,133 @@
+import { spawn } from "node:child_process";
+import { closeSync, existsSync, openSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { describeCodexCli, resolveCodexCli } from "./codex-cli.js";
+import { findLatestDatabase } from "./codex-state.js";
+import { describePiCli, resolvePiCli } from "./pi-cli.js";
+const APP_NAME = "nordrelay";
+const DEFAULT_HOME = path.join(os.homedir(), ".codex", "nordrelay");
+const SECRET_RE = /(bot|token|api[_-]?key|authorization|bearer|password|secret)(["'=: ]+)([^\s"',]+)/gi;
+export function getConnectorHome() {
+    return process.env.NORDRELAY_HOME || DEFAULT_HOME;
+}
+export function getConnectorStatePath() {
+    return process.env.NORDRELAY_STATE_FILE || path.join(getConnectorHome(), "state.json");
+}
+export function getConnectorLogPath() {
+    return path.join(getConnectorHome(), "nordrelay.log");
+}
+export function getUpdateLogPath() {
+    return path.join(getConnectorHome(), "update.log");
+}
+export async function readConnectorState() {
+    try {
+        return JSON.parse(await readFile(getConnectorStatePath(), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+export async function readLogTail(lines = 80, filePath = getConnectorLogPath()) {
+    const boundedLines = Math.min(Math.max(lines, 1), 300);
+    try {
+        const contents = await readFile(filePath, "utf8");
+        return redactSecrets(contents.split(/\r?\n/).slice(-boundedLines).join("\n").trim());
+    }
+    catch (error) {
+        return `Cannot read log: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+export async function getPackageVersion() {
+    try {
+        const pkg = JSON.parse(await readFile(path.join(getSourceRoot(), "package.json"), "utf8"));
+        return typeof pkg.version === "string" ? pkg.version : "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+export async function getConnectorHealth() {
+    const state = await readConnectorState();
+    const version = await getPackageVersion();
+    const pidRunning = isProcessRunning(state.pid);
+    const appPidRunning = isProcessRunning(state.appPid);
+    return {
+        version,
+        state,
+        pidRunning,
+        appPidRunning,
+        codexCli: describeCodexCli(resolveCodexCli()),
+        piCli: describePiCli(resolvePiCli()),
+        stateFile: getConnectorStatePath(),
+        logFile: getConnectorLogPath(),
+        databasePath: findLatestDatabase(),
+        uptimeSeconds: Math.max(0, Math.round(process.uptime())),
+    };
+}
+export function spawnConnectorRestart() {
+    const script = getWrapperScriptPath();
+    const child = spawn(process.execPath, [script, "restart", "--keep-pending-updates"], {
+        cwd: getSourceRoot(),
+        detached: true,
+        env: process.env,
+        stdio: "ignore",
+    });
+    child.unref();
+}
+export function spawnSelfUpdate() {
+    const sourceRoot = getSourceRoot();
+    const script = getWrapperScriptPath();
+    const updateLog = getUpdateLogPath();
+    const logFd = openSync(updateLog, "a");
+    const command = [
+        "set -e",
+        `printf '\\n[%s] Starting connector self-update\\n' "$(date -Is)"`,
+        "git pull --ff-only origin main",
+        "npm install",
+        "npm run check",
+        "npm test",
+        "npm run build",
+        `printf '[%s] Checks passed; restarting connector\\n' "$(date -Is)"`,
+        `${shellQuote(process.execPath)} ${shellQuote(script)} restart --keep-pending-updates`,
+    ].join(" && ");
+    const child = spawn("sh", ["-lc", command], {
+        cwd: sourceRoot,
+        detached: true,
+        env: process.env,
+        stdio: ["ignore", logFd, logFd],
+    });
+    child.unref();
+    closeSync(logFd);
+    return updateLog;
+}
+export function getSourceRoot() {
+    return process.env.NORDRELAY_SOURCE_ROOT || process.cwd();
+}
+function getWrapperScriptPath() {
+    const sourceRoot = getSourceRoot();
+    const script = path.join(sourceRoot, "plugins", APP_NAME, "scripts", `${APP_NAME}.mjs`);
+    if (existsSync(script)) {
+        return script;
+    }
+    return path.join(process.cwd(), "plugins", APP_NAME, "scripts", `${APP_NAME}.mjs`);
+}
+function isProcessRunning(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function redactSecrets(text) {
+    return text.replace(SECRET_RE, "$1$2[redacted]");
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}

package/dist/persistence.js

@@ -0,0 +1,65 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+export function writeJsonFileAtomic(filePath, value) {
+    writeTextFileAtomic(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+export function writeTextFileAtomic(filePath, value) {
+    const dir = path.dirname(filePath);
+    mkdirSync(dir, { recursive: true });
+    const backupPath = `${filePath}.bak`;
+    const tempPath = path.join(dir, `.${path.basename(filePath)}.${process.pid}.${Date.now()}.tmp`);
+    try {
+        if (existsSync(filePath)) {
+            copyFileSync(filePath, backupPath);
+        }
+        writeFileSync(tempPath, value, "utf8");
+        renameSync(tempPath, filePath);
+    }
+    catch (error) {
+        rmSync(tempPath, { force: true });
+        throw error;
+    }
+}
+export function readJsonFileWithBackup(filePath) {
+    const primary = readJsonFile(filePath);
+    if (primary.ok) {
+        return { value: primary.value, recoveredFromBackup: false };
+    }
+    const backupPath = `${filePath}.bak`;
+    const backup = readJsonFile(backupPath);
+    if (backup.ok) {
+        return {
+            value: backup.value,
+            recoveredFromBackup: true,
+            error: primary.error,
+        };
+    }
+    if (primary.error && existsSync(filePath)) {
+        const corruptPath = `${filePath}.corrupt-${Date.now()}`;
+        try {
+            copyFileSync(filePath, corruptPath);
+        }
+        catch {
+            // Best-effort only. The original file remains untouched.
+        }
+    }
+    return {
+        value: undefined,
+        recoveredFromBackup: false,
+        error: primary.error ?? backup.error,
+    };
+}
+function readJsonFile(filePath) {
+    if (!existsSync(filePath)) {
+        return { ok: false };
+    }
+    try {
+        return { ok: true, value: JSON.parse(readFileSync(filePath, "utf8")) };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

package/dist/pi-cli.js

@@ -0,0 +1,19 @@
+import { findExecutableOnPath } from "./codex-cli.js";
+export function resolvePiCli(env = process.env, explicitPath) {
+    const configuredPath = optionalString(explicitPath) ?? optionalString(env.PI_CLI_PATH);
+    if (configuredPath) {
+        return { path: configuredPath, source: "env" };
+    }
+    const pathMatch = findExecutableOnPath("pi", env.PATH);
+    return pathMatch ? { path: pathMatch, source: "path" } : { source: "missing" };
+}
+export function describePiCli(resolution) {
+    if (resolution.path) {
+        return `${resolution.source} (${resolution.path})`;
+    }
+    return "missing";
+}
+function optionalString(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}

package/dist/pi-rpc.js

@@ -0,0 +1,158 @@
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+export class PiRpcClient {
+    options;
+    child = null;
+    pending = new Map();
+    handlers = new Set();
+    stderrBuffer = "";
+    constructor(options) {
+        this.options = options;
+    }
+    updateOptions(options) {
+        this.options = { ...this.options, ...options };
+    }
+    onEvent(handler) {
+        this.handlers.add(handler);
+        return () => {
+            this.handlers.delete(handler);
+        };
+    }
+    async send(command, timeoutMs = 30_000) {
+        this.ensureStarted();
+        const child = this.child;
+        if (!child || child.stdin.destroyed) {
+            throw new Error("Pi RPC process is not available");
+        }
+        const id = typeof command.id === "string" ? command.id : `nr-${randomUUID()}`;
+        const payload = { ...command, id };
+        const response = await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`Pi RPC command timed out: ${String(command.type ?? "unknown")}`));
+            }, timeoutMs);
+            timeout.unref?.();
+            this.pending.set(id, { resolve, reject, timeout });
+            child.stdin.write(`${JSON.stringify(payload)}\n`, (error) => {
+                if (!error) {
+                    return;
+                }
+                const pending = this.pending.get(id);
+                if (pending) {
+                    clearTimeout(pending.timeout);
+                    this.pending.delete(id);
+                    pending.reject(error);
+                }
+            });
+        });
+        if (!response.success) {
+            throw new Error(response.error || `Pi RPC command failed: ${String(command.type ?? "unknown")}`);
+        }
+        return response;
+    }
+    ensureStarted() {
+        if (this.child && !this.child.killed) {
+            return;
+        }
+        const args = ["--mode", "rpc"];
+        if (this.options.sessionDir) {
+            args.push("--session-dir", this.options.sessionDir);
+        }
+        if (this.options.sessionPath) {
+            args.push("--session", this.options.sessionPath);
+        }
+        if (this.options.model) {
+            args.push("--model", this.options.model);
+        }
+        if (this.options.thinking) {
+            args.push("--thinking", this.options.thinking);
+        }
+        const child = spawn(this.options.commandPath, args, {
+            cwd: this.options.cwd,
+            env: { ...process.env, ...this.options.env },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.child = child;
+        this.stderrBuffer = "";
+        attachJsonlReader(child.stdout, (line) => this.handleLine(line));
+        child.stderr.on("data", (chunk) => {
+            this.stderrBuffer = appendWithLimit(this.stderrBuffer, typeof chunk === "string" ? chunk : chunk.toString("utf8"), 20_000);
+        });
+        child.on("error", (error) => {
+            this.rejectAll(error instanceof Error ? error : new Error(String(error)));
+        });
+        child.on("exit", (code, signal) => {
+            const reason = signal ? `signal ${signal}` : `exit code ${code ?? "unknown"}`;
+            const stderr = this.stderrBuffer.trim();
+            this.rejectAll(new Error(`Pi RPC process exited (${reason})${stderr ? `: ${stderr}` : ""}`));
+            this.child = null;
+        });
+    }
+    stop() {
+        const child = this.child;
+        this.child = null;
+        this.rejectAll(new Error("Pi RPC process stopped"));
+        child?.kill("SIGTERM");
+    }
+    handleLine(line) {
+        if (!line.trim()) {
+            return;
+        }
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (message.type === "response" && typeof message.id === "string") {
+            const pending = this.pending.get(message.id);
+            if (pending) {
+                clearTimeout(pending.timeout);
+                this.pending.delete(message.id);
+                pending.resolve(message);
+                return;
+            }
+        }
+        for (const handler of this.handlers) {
+            handler(message);
+        }
+    }
+    rejectAll(error) {
+        for (const [id, pending] of this.pending.entries()) {
+            clearTimeout(pending.timeout);
+            pending.reject(error);
+            this.pending.delete(id);
+        }
+    }
+}
+function attachJsonlReader(stream, onLine) {
+    const decoder = new StringDecoder("utf8");
+    let buffer = "";
+    stream.on("data", (chunk) => {
+        buffer += typeof chunk === "string" ? chunk : decoder.write(chunk);
+        while (true) {
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex === -1) {
+                break;
+            }
+            let line = buffer.slice(0, newlineIndex);
+            buffer = buffer.slice(newlineIndex + 1);
+            if (line.endsWith("\r")) {
+                line = line.slice(0, -1);
+            }
+            onLine(line);
+        }
+    });
+    stream.on("end", () => {
+        buffer += decoder.end();
+        if (buffer.length > 0) {
+            onLine(buffer.endsWith("\r") ? buffer.slice(0, -1) : buffer);
+        }
+    });
+}
+function appendWithLimit(current, addition, limit) {
+    const next = `${current}${addition}`;
+    return next.length <= limit ? next : next.slice(next.length - limit);
+}