@nordbyte/nordrelay 0.2.1 → 0.3.1

package/dist/operations.js

@@ -1,14 +1,18 @@
-import { spawn } from "node:child_process";
-import { closeSync, existsSync, openSync } from "node:fs";
-import { readFile } from "node:fs/promises";
+import { spawn, spawnSync } from "node:child_process";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, writeFileSync } from "node:fs";
+import { readFile, stat } 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 PACKAGE_NAME = "@nordbyte/nordrelay";
+const CODEX_PACKAGE_NAME = "@openai/codex";
+const PI_PACKAGE_NAME = "@mariozechner/pi-coding-agent";
+const DEFAULT_HOME = path.join(os.homedir(), ".nordrelay");
 const SECRET_RE = /(bot|token|api[_-]?key|authorization|bearer|password|secret)(["'=: ]+)([^\s"',]+)/gi;
+const DEFAULT_VERSION_CACHE_TTL_MS = 60 * 60 * 1000;
 export function getConnectorHome() {
     return process.env.NORDRELAY_HOME || DEFAULT_HOME;
 }
@@ -39,6 +43,30 @@ export async function readLogTail(lines = 80, filePath = getConnectorLogPath())
         return `Cannot read log: ${error instanceof Error ? error.message : String(error)}`;
     }
 }
+export async function readFormattedLogTail(lines = 80, filePath = getConnectorLogPath()) {
+    const boundedLines = Math.min(Math.max(lines, 1), 300);
+    try {
+        const [contents, stats] = await Promise.all([readFile(filePath, "utf8"), stat(filePath)]);
+        const rawLines = contents.split(/\r?\n/).filter((line) => line.trim().length > 0).slice(-boundedLines);
+        const formatted = rawLines.map(formatLogLine).join("\n");
+        return {
+            filePath,
+            requestedLines: boundedLines,
+            lineCount: rawLines.length,
+            updatedAt: stats.mtime,
+            plain: redactSecrets(formatted),
+        };
+    }
+    catch (error) {
+        return {
+            filePath,
+            requestedLines: boundedLines,
+            lineCount: 0,
+            updatedAt: null,
+            plain: `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"));
@@ -48,18 +76,55 @@ export async function getPackageVersion() {
         return "unknown";
     }
 }
+export async function getVersionChecks(options = {}) {
+    const nordrelayVersion = await getPackageVersion();
+    const codexCli = resolveCodexCli();
+    const piCli = resolvePiCli(process.env, options.piCliPath);
+    const codexVersionLabel = codexCli.path
+        ? detectCliVersion(codexCli.path)
+        : readInstalledPackageVersion(CODEX_PACKAGE_NAME) ?? "not installed";
+    const piVersionLabel = piCli.path ? detectCliVersion(piCli.path) : "not installed";
+    return {
+        nordrelay: buildVersionCheck({
+            label: "NordRelay",
+            packageName: PACKAGE_NAME,
+            installedLabel: nordrelayVersion,
+            installedVersion: extractVersion(nordrelayVersion),
+        }),
+        codex: buildVersionCheck({
+            label: "Codex",
+            packageName: CODEX_PACKAGE_NAME,
+            installedLabel: codexVersionLabel,
+            installedVersion: extractVersion(codexVersionLabel),
+            notInstalled: codexVersionLabel === "not installed",
+        }),
+        pi: buildVersionCheck({
+            label: "Pi",
+            packageName: PI_PACKAGE_NAME,
+            installedLabel: piVersionLabel,
+            installedVersion: extractVersion(piVersionLabel),
+            notInstalled: piVersionLabel === "not installed",
+        }),
+    };
+}
 export async function getConnectorHealth() {
     const state = await readConnectorState();
     const version = await getPackageVersion();
     const pidRunning = isProcessRunning(state.pid);
     const appPidRunning = isProcessRunning(state.appPid);
+    const codexCli = resolveCodexCli();
+    const piCli = resolvePiCli();
     return {
         version,
         state,
         pidRunning,
         appPidRunning,
-        codexCli: describeCodexCli(resolveCodexCli()),
-        piCli: describePiCli(resolvePiCli()),
+        codexCli: describeCodexCli(codexCli),
+        codexCliPath: codexCli.path ?? null,
+        codexCliVersion: detectCliVersion(codexCli.path),
+        piCli: describePiCli(piCli),
+        piCliPath: piCli.path ?? null,
+        piCliVersion: detectCliVersion(piCli.path),
         stateFile: getConnectorStatePath(),
         logFile: getConnectorLogPath(),
         databasePath: findLatestDatabase(),
@@ -80,17 +145,15 @@ export function spawnSelfUpdate() {
     const sourceRoot = getSourceRoot();
     const script = getWrapperScriptPath();
     const updateLog = getUpdateLogPath();
+    const method = detectSelfUpdateMethod(sourceRoot);
+    const commands = method === "npm"
+        ? buildNpmSelfUpdateCommands()
+        : buildGitSelfUpdateCommands(script);
     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`,
+        `printf '\\n[%s] Starting ${method} connector self-update\\n' "$(date -Is)"`,
+        ...commands,
     ].join(" && ");
     const child = spawn("sh", ["-lc", command], {
         cwd: sourceRoot,
@@ -100,11 +163,25 @@ export function spawnSelfUpdate() {
     });
     child.unref();
     closeSync(logFd);
-    return updateLog;
+    return {
+        logPath: updateLog,
+        method,
+        sourceRoot,
+        summary: method === "npm"
+            ? `Install latest ${PACKAGE_NAME} with npm, verify the CLI, and restart.`
+            : "Pull origin/main, install dependencies, run check, tests, build, and restart.",
+    };
 }
 export function getSourceRoot() {
     return process.env.NORDRELAY_SOURCE_ROOT || process.cwd();
 }
+export function detectSelfUpdateMethod(sourceRoot = getSourceRoot()) {
+    const override = process.env.NORDRELAY_UPDATE_METHOD?.trim().toLowerCase();
+    if (override === "npm" || override === "git") {
+        return override;
+    }
+    return existsSync(path.join(sourceRoot, ".git")) ? "git" : "npm";
+}
 function getWrapperScriptPath() {
     const sourceRoot = getSourceRoot();
     const script = path.join(sourceRoot, "plugins", APP_NAME, "scripts", `${APP_NAME}.mjs`);
@@ -128,6 +205,254 @@ function isProcessRunning(pid) {
 function redactSecrets(text) {
     return text.replace(SECRET_RE, "$1$2[redacted]");
 }
+function buildGitSelfUpdateCommands(script) {
+    return [
+        "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`,
+    ];
+}
+function buildNpmSelfUpdateCommands() {
+    return [
+        `${resolveNpmCommand()} install -g ${PACKAGE_NAME}@latest`,
+        "nordrelay version",
+        `printf '[%s] npm update finished; restarting connector\\n' "$(date -Is)"`,
+        "nordrelay restart --keep-pending-updates",
+    ];
+}
+function resolveNpmCommand() {
+    const npmExecPath = process.env.npm_execpath;
+    if (npmExecPath && existsSync(npmExecPath)) {
+        return `${shellQuote(process.execPath)} ${shellQuote(npmExecPath)}`;
+    }
+    return "npm";
+}
+function detectCliVersion(commandPath) {
+    if (!commandPath) {
+        return "not installed";
+    }
+    const result = spawnSync(commandPath, ["--version"], {
+        encoding: "utf8",
+        timeout: 3000,
+        windowsHide: true,
+    });
+    const output = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
+    if (result.error) {
+        return `unavailable (${result.error.message})`;
+    }
+    if (result.status !== 0) {
+        return output ? `unavailable (${output})` : `unavailable (exit ${result.status ?? "unknown"})`;
+    }
+    return output || "unknown";
+}
+function buildVersionCheck(options) {
+    if (options.notInstalled) {
+        return {
+            label: options.label,
+            packageName: options.packageName,
+            installedLabel: "not installed",
+            installedVersion: null,
+            latestVersion: null,
+            status: "not-installed",
+        };
+    }
+    const latest = detectLatestNpmVersion(options.packageName);
+    if (!options.installedVersion || !latest.version) {
+        return {
+            label: options.label,
+            packageName: options.packageName,
+            installedLabel: options.installedLabel,
+            installedVersion: options.installedVersion,
+            latestVersion: latest.version,
+            status: "unknown",
+            detail: latest.error ?? "Could not parse installed version",
+        };
+    }
+    return {
+        label: options.label,
+        packageName: options.packageName,
+        installedLabel: options.installedLabel,
+        installedVersion: options.installedVersion,
+        latestVersion: latest.version,
+        status: compareVersions(options.installedVersion, latest.version) < 0 ? "outdated" : "current",
+        detail: latest.error,
+    };
+}
+function detectLatestNpmVersion(packageName) {
+    const cached = readVersionCache(packageName);
+    if (cached) {
+        return cached;
+    }
+    const result = spawnSync("npm", ["view", packageName, "version", "--registry=https://registry.npmjs.org"], {
+        encoding: "utf8",
+        timeout: 5000,
+        windowsHide: true,
+    });
+    const output = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
+    if (result.error) {
+        return { version: null, error: result.error.message };
+    }
+    if (result.status !== 0) {
+        return { version: null, error: output || `npm exited ${result.status ?? "unknown"}` };
+    }
+    const resolved = { version: output.split(/\r?\n/).at(-1)?.trim() || null };
+    writeVersionCache(packageName, resolved.version);
+    return resolved;
+}
+function readVersionCache(packageName) {
+    const ttlMs = parseVersionCacheTtlMs();
+    if (ttlMs <= 0) {
+        return null;
+    }
+    try {
+        const payload = JSON.parse(readFileSync(getVersionCachePath(), "utf8"));
+        const entry = payload.packages?.[packageName];
+        if (!entry || typeof entry.version !== "string" || typeof entry.checkedAt !== "number") {
+            return null;
+        }
+        if (Date.now() - entry.checkedAt > ttlMs) {
+            return null;
+        }
+        return { version: entry.version };
+    }
+    catch {
+        return null;
+    }
+}
+function writeVersionCache(packageName, version) {
+    if (!version || parseVersionCacheTtlMs() <= 0) {
+        return;
+    }
+    const filePath = getVersionCachePath();
+    try {
+        const existing = existsSync(filePath)
+            ? JSON.parse(readFileSync(filePath, "utf8"))
+            : {};
+        const packages = existing.packages ?? {};
+        packages[packageName] = { version, checkedAt: Date.now() };
+        mkdirSync(path.dirname(filePath), { recursive: true });
+        writeFileSync(filePath, `${JSON.stringify({ packages }, null, 2)}\n`, "utf8");
+    }
+    catch {
+        // Best-effort cache only.
+    }
+}
+function getVersionCachePath() {
+    return path.join(getConnectorHome(), "version-cache.json");
+}
+function parseVersionCacheTtlMs() {
+    const raw = process.env.NORDRELAY_VERSION_CACHE_TTL_MS;
+    if (!raw) {
+        return DEFAULT_VERSION_CACHE_TTL_MS;
+    }
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) ? Math.max(0, Math.floor(parsed)) : DEFAULT_VERSION_CACHE_TTL_MS;
+}
+function readInstalledPackageVersion(packageName) {
+    try {
+        const packagePath = path.join(getSourceRoot(), "node_modules", ...packageName.split("/"), "package.json");
+        const pkg = JSON.parse(readFileSyncUtf8(packagePath));
+        return typeof pkg.version === "string" ? pkg.version : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readFileSyncUtf8(filePath) {
+    return readFileSync(filePath, "utf8");
+}
+function extractVersion(value) {
+    const match = value.match(/\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?/);
+    return match?.[0] ?? null;
+}
+function compareVersions(left, right) {
+    const leftParts = parseVersionParts(left);
+    const rightParts = parseVersionParts(right);
+    for (let index = 0; index < Math.max(leftParts.length, rightParts.length); index += 1) {
+        const diff = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
+        if (diff !== 0) {
+            return diff;
+        }
+    }
+    return 0;
+}
+function parseVersionParts(value) {
+    return value.split(/[.-]/).slice(0, 3).map((part) => Number.parseInt(part, 10) || 0);
+}
 function shellQuote(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
+function formatLogLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return "";
+    }
+    const parsedJson = parseJsonLogLine(trimmed);
+    if (parsedJson) {
+        return parsedJson;
+    }
+    const textRecord = trimmed.match(/^\[(?<timestamp>[^\]]+)\]\s+(?<level>INFO|WARN|ERROR)\s+(?<message>.*)$/i);
+    if (textRecord?.groups) {
+        return [
+            formatLogTimestamp(textRecord.groups.timestamp),
+            textRecord.groups.level.toUpperCase().padEnd(5),
+            textRecord.groups.message,
+        ].join(" ");
+    }
+    const timestampedShellLine = trimmed.match(/^\[(?<timestamp>[^\]]+)\]\s+(?<message>.*)$/);
+    if (timestampedShellLine?.groups) {
+        return [
+            formatLogTimestamp(timestampedShellLine.groups.timestamp),
+            "INFO ".padEnd(5),
+            timestampedShellLine.groups.message,
+        ].join(" ");
+    }
+    return trimmed;
+}
+function parseJsonLogLine(line) {
+    if (!line.startsWith("{")) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(line);
+        const timestamp = typeof parsed.ts === "string"
+            ? parsed.ts
+            : typeof parsed.timestamp === "string"
+                ? parsed.timestamp
+                : null;
+        const level = typeof parsed.level === "string" ? parsed.level.toUpperCase() : "INFO";
+        const message = typeof parsed.message === "string" ? parsed.message : JSON.stringify(parsed);
+        const event = typeof parsed.event === "string" && parsed.event !== "console" ? ` ${parsed.event}` : "";
+        return [
+            formatLogTimestamp(timestamp),
+            `${level}${event}`.slice(0, 12).padEnd(12),
+            message,
+        ].join(" ");
+    }
+    catch {
+        return null;
+    }
+}
+function formatLogTimestamp(value) {
+    if (!value) {
+        return "unknown time".padEnd(25);
+    }
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime())) {
+        return value.padEnd(25).slice(0, 25);
+    }
+    return formatLocalTimestamp(parsed);
+}
+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");
+}

package/dist/prompt-store.js

@@ -1,14 +1,17 @@
 import { randomUUID } from "node:crypto";
-import { mkdirSync } from "node:fs";
-import path from "node:path";
-import { readJsonFileWithBackup, writeJsonFileAtomic } from "./persistence.js";
+import { createDocumentStore } from "./state-backend.js";
 export class PromptStore {
-    persistPath;
+    store;
     lastPrompts = new Map();
     queues = new Map();
     pausedContexts = new Set();
-    constructor(workspace) {
-        this.persistPath = path.join(workspace, ".nordrelay", "prompts.json");
+    constructor(workspace, backend = "json") {
+        this.store = createDocumentStore({
+            workspace,
+            fileName: "prompts.json",
+            sqliteKey: "prompts",
+            backend,
+        });
         this.load();
     }
     setLastPrompt(contextKey, prompt) {
@@ -18,12 +21,13 @@ export class PromptStore {
     getLastPrompt(contextKey) {
         return this.lastPrompts.get(contextKey);
     }
-    enqueue(contextKey, prompt) {
+    enqueue(contextKey, prompt, options = {}) {
         const item = {
             ...prompt,
             id: createQueueId(),
             contextKey,
             createdAt: Date.now(),
+            notBefore: options.notBefore,
         };
         const queue = this.queues.get(contextKey) ?? [];
         queue.push(item);
@@ -39,7 +43,15 @@ export class PromptStore {
     }
     dequeue(contextKey) {
         const queue = this.queues.get(contextKey);
-        const item = queue?.shift();
+        if (!queue || queue.length === 0) {
+            return undefined;
+        }
+        const now = Date.now();
+        const index = queue.findIndex((queued) => !queued.notBefore || queued.notBefore <= now);
+        if (index === -1) {
+            return undefined;
+        }
+        const [item] = queue.splice(index, 1);
         if (!queue || queue.length === 0) {
             this.queues.delete(contextKey);
         }
@@ -53,6 +65,16 @@ export class PromptStore {
     list(contextKey) {
         return [...(this.queues.get(contextKey) ?? [])];
     }
+    get(contextKey, id) {
+        return this.queues.get(contextKey)?.find((item) => item.id === id);
+    }
+    nextRunnableAt(contextKey) {
+        const timestamps = (this.queues.get(contextKey) ?? [])
+            .map((item) => item.notBefore)
+            .filter((value) => typeof value === "number")
+            .sort((left, right) => left - right);
+        return timestamps[0] ?? null;
+    }
     listContextKeys() {
         return [...new Set([...this.queues.keys(), ...this.pausedContexts])];
     }
@@ -143,13 +165,12 @@ export class PromptStore {
     }
     persist() {
         try {
-            mkdirSync(path.dirname(this.persistPath), { recursive: true });
             const payload = {
                 lastPrompts: Object.fromEntries(this.lastPrompts.entries()),
                 queues: Object.fromEntries(this.queues.entries()),
                 pausedContexts: [...this.pausedContexts],
             };
-            writeJsonFileAtomic(this.persistPath, payload);
+            this.store.write(payload);
         }
         catch (error) {
             console.warn("Failed to persist prompt store:", error instanceof Error ? error.message : String(error));
@@ -157,7 +178,7 @@ export class PromptStore {
     }
     load() {
         try {
-            const payload = readJsonFileWithBackup(this.persistPath).value;
+            const payload = this.store.read();
             if (!payload) {
                 return;
             }
@@ -218,6 +239,7 @@ function isQueuedPrompt(value) {
         typeof value.id === "string" &&
         typeof value.contextKey === "string" &&
         typeof value.createdAt === "number" &&
+        (value.notBefore === undefined || typeof value.notBefore === "number") &&
         (value.updatedAt === undefined || typeof value.updatedAt === "number") &&
         (value.attempts === undefined || typeof value.attempts === "number") &&
         (value.lastError === undefined || typeof value.lastError === "string");