@nordbyte/nordrelay 0.3.1 → 0.4.1

package/dist/agent-updates.js

@@ -0,0 +1,294 @@
+import { spawn } from "node:child_process";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { agentLabel } from "./agent.js";
+import { resolveClaudeCodeCli } from "./claude-code-cli.js";
+import { resolveCodexCli } from "./codex-cli.js";
+import { resolveHermesCli } from "./hermes-cli.js";
+import { resolveOpenClawCli } from "./openclaw-cli.js";
+import { getAgentUpdateLogPath, getConnectorHome } from "./operations.js";
+import { resolvePiCli } from "./pi-cli.js";
+import { redactText } from "./redaction.js";
+export class AgentUpdateManager {
+    options;
+    jobs = new Map();
+    home;
+    manifestPath;
+    aggregateLogPath;
+    constructor(options = {}) {
+        this.options = options;
+        this.home = options.home ?? getConnectorHome();
+        this.manifestPath = path.join(this.home, "updates", "jobs.json");
+        this.aggregateLogPath = getAgentUpdateLogPath(this.home);
+        this.loadPersistedJobs();
+    }
+    list() {
+        return [...this.jobs.values()]
+            .sort((left, right) => right.startedAt.localeCompare(left.startedAt))
+            .map((job) => this.snapshot(job));
+    }
+    get(id) {
+        const job = this.jobs.get(id);
+        return job ? this.snapshot(job) : null;
+    }
+    readLog(id) {
+        const job = this.requireJob(id);
+        try {
+            return { job: this.snapshot(job), plain: redactText(readFileSync(job.logPath, "utf8")) };
+        }
+        catch (error) {
+            return {
+                job: this.snapshot(job),
+                plain: `Cannot read update log: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    start(agentId, context = {}) {
+        const running = [...this.jobs.values()].find((job) => job.agentId === agentId && job.status === "running");
+        if (running) {
+            throw new Error(`${agentLabel(agentId)} update is already running.`);
+        }
+        const plan = resolveAgentUpdatePlan(agentId, { ...context, env: context.env ?? this.options.env });
+        const now = new Date().toISOString();
+        const id = `${agentId.replace(/[^a-z0-9]/gi, "")}-${Date.now().toString(36)}`;
+        const logPath = path.join(this.home, "updates", `${id}.log`);
+        mkdirSync(path.dirname(logPath), { recursive: true });
+        const job = {
+            id,
+            agentId,
+            agentLabel: plan.agentLabel,
+            status: "running",
+            method: plan.method,
+            command: plan.command,
+            args: plan.args,
+            cwd: plan.cwd,
+            summary: plan.summary,
+            interactive: plan.interactive,
+            canInput: true,
+            needsInput: false,
+            startedAt: now,
+            updatedAt: now,
+            logPath,
+            ownerPid: process.pid,
+            output: "",
+            outputTail: "",
+        };
+        this.jobs.set(id, job);
+        this.persistJobs();
+        this.append(job, [
+            `[${now}] Starting ${job.agentLabel} update`,
+            `Method: ${job.method}`,
+            `Command: ${[job.command, ...job.args].join(" ")}`,
+            `Working directory: ${job.cwd}`,
+            "",
+        ].join("\n"));
+        const child = spawn(plan.command, plan.args, {
+            cwd: plan.cwd,
+            env: { ...process.env, ...(this.options.env ?? {}), ...(context.env ?? {}) },
+            shell: process.platform === "win32",
+            windowsHide: true,
+            stdio: "pipe",
+        });
+        job.child = child;
+        child.stdin.setDefaultEncoding("utf8");
+        child.stdout.on("data", (chunk) => this.append(job, chunk.toString("utf8")));
+        child.stderr.on("data", (chunk) => this.append(job, chunk.toString("utf8")));
+        child.on("error", (error) => {
+            this.finish(job, "failed", null, null, error.message);
+        });
+        child.on("close", (code, signal) => {
+            if (job.status !== "running") {
+                return;
+            }
+            this.finish(job, code === 0 ? "completed" : "failed", code, signal, code === 0 ? undefined : `Update exited with code ${code ?? "unknown"}`);
+        });
+        this.emit(job);
+        return this.snapshot(job);
+    }
+    sendInput(id, input) {
+        const job = this.requireJob(id);
+        if (job.status !== "running" || !job.child?.stdin.writable) {
+            throw new Error("Update job is not accepting input.");
+        }
+        const line = input.endsWith("\n") ? input : `${input}\n`;
+        job.child.stdin.write(line);
+        job.needsInput = false;
+        this.append(job, `[${new Date().toISOString()}] Input sent from dashboard.\n`);
+        return this.snapshot(job);
+    }
+    cancel(id) {
+        const job = this.requireJob(id);
+        if (job.status !== "running") {
+            return this.snapshot(job);
+        }
+        job.child?.kill("SIGTERM");
+        this.finish(job, "cancelled", null, "SIGTERM", "Cancelled from dashboard.");
+        return this.snapshot(job);
+    }
+    cancelAll() {
+        for (const job of this.jobs.values()) {
+            if (job.status === "running") {
+                job.child?.kill("SIGTERM");
+            }
+        }
+    }
+    requireJob(id) {
+        const job = this.jobs.get(id);
+        if (!job) {
+            throw new Error(`Unknown update job: ${id}`);
+        }
+        return job;
+    }
+    append(job, text) {
+        const redacted = redactText(text);
+        job.output += redacted;
+        if (job.output.length > 120_000) {
+            job.output = job.output.slice(-120_000);
+        }
+        job.outputTail = job.output.slice(-16_000);
+        job.updatedAt = new Date().toISOString();
+        job.needsInput = job.status === "running" && looksLikePrompt(job.outputTail);
+        writeFileSync(job.logPath, redacted, { flag: "a", encoding: "utf8" });
+        this.appendAggregate(job, redacted);
+        this.persistJobs();
+        this.emit(job);
+    }
+    finish(job, status, code, signal, error) {
+        job.status = status;
+        job.canInput = false;
+        job.needsInput = false;
+        job.exitCode = code;
+        job.signal = signal;
+        job.error = error ? redactText(error) : undefined;
+        job.finishedAt = new Date().toISOString();
+        job.updatedAt = job.finishedAt;
+        job.child = undefined;
+        this.append(job, `\n[${job.finishedAt}] ${job.agentLabel} update ${status}${error ? `: ${job.error}` : ""}\n`);
+    }
+    emit(job) {
+        this.options.onUpdate?.(this.snapshot(job));
+    }
+    snapshot(job) {
+        const { child: _child, output: _output, ...snapshot } = job;
+        return { ...snapshot };
+    }
+    loadPersistedJobs() {
+        if (!existsSync(this.manifestPath)) {
+            return;
+        }
+        try {
+            const parsed = JSON.parse(readFileSync(this.manifestPath, "utf8"));
+            let changed = false;
+            for (const snapshot of parsed) {
+                const staleRunning = snapshot.status === "running" && !isProcessRunning(snapshot.ownerPid);
+                if (staleRunning) {
+                    changed = true;
+                }
+                const job = {
+                    ...snapshot,
+                    status: staleRunning ? "failed" : snapshot.status,
+                    canInput: false,
+                    needsInput: false,
+                    error: staleRunning
+                        ? "Update process was still running when NordRelay restarted; inspect the agent update log before retrying."
+                        : snapshot.error,
+                    finishedAt: staleRunning ? new Date().toISOString() : snapshot.finishedAt,
+                    updatedAt: staleRunning ? new Date().toISOString() : snapshot.updatedAt,
+                    output: snapshot.outputTail ?? "",
+                    outputTail: snapshot.outputTail ?? "",
+                };
+                this.jobs.set(job.id, job);
+            }
+            if (changed) {
+                this.persistJobs();
+            }
+        }
+        catch {
+            this.jobs.clear();
+        }
+    }
+    persistJobs() {
+        mkdirSync(path.dirname(this.manifestPath), { recursive: true });
+        const snapshots = this.list().slice(0, 100);
+        writeFileSync(this.manifestPath, `${JSON.stringify(snapshots, null, 2)}\n`, "utf8");
+    }
+    appendAggregate(job, text) {
+        const lines = text.split(/\r?\n/).filter((line) => line.trim().length > 0);
+        if (lines.length === 0) {
+            return;
+        }
+        mkdirSync(path.dirname(this.aggregateLogPath), { recursive: true });
+        const now = new Date().toISOString();
+        const prefix = `[${now}] INFO [${job.id}]`;
+        appendFileSync(this.aggregateLogPath, `${lines.map((line) => `${prefix} ${line}`).join("\n")}\n`, "utf8");
+    }
+}
+function isProcessRunning(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function resolveAgentUpdatePlan(agentId, context = {}) {
+    const env = context.env ?? process.env;
+    switch (agentId) {
+        case "codex": {
+            const cli = resolveCodexCli(env);
+            if (!cli.path) {
+                throw new Error("Codex CLI is not installed on PATH. Install or update it with npm i -g @openai/codex@latest.");
+            }
+            return plan(agentId, "codex update", cli.path, ["update"], "Runs the Codex CLI self-updater. If this install cannot self-update, use npm i -g @openai/codex@latest.", env);
+        }
+        case "pi": {
+            const cli = resolvePiCli(env, context.piCliPath);
+            if (!cli.path) {
+                throw new Error("Pi CLI is not installed on PATH. Install or update it with npm install -g @earendil-works/pi-coding-agent@latest.");
+            }
+            return plan(agentId, "pi update pi", cli.path, ["update", "pi"], "Updates only the Pi coding agent, not installed Pi extensions.", env);
+        }
+        case "hermes": {
+            const cli = resolveHermesCli(env, context.hermesCliPath);
+            if (!cli.path) {
+                throw new Error("Hermes CLI is not installed on PATH. Install Hermes with the official installer before updating.");
+            }
+            return plan(agentId, "hermes update --yes", cli.path, ["update", "--yes"], "Runs the Hermes git/dependency updater with confirmation prompts accepted where supported.", env);
+        }
+        case "openclaw": {
+            const cli = resolveOpenClawCli(env, context.openClawCliPath);
+            if (!cli.path) {
+                throw new Error("OpenClaw CLI is not installed on PATH. Install OpenClaw before updating.");
+            }
+            return plan(agentId, "openclaw update --yes", cli.path, ["update", "--yes"], "Runs the OpenClaw updater, which detects npm/git installs and may restart the Gateway.", env);
+        }
+        case "claude-code": {
+            const cli = resolveClaudeCodeCli(env, context.claudeCodeCliPath);
+            if (!cli.path) {
+                throw new Error("Claude Code host CLI is not installed on PATH. Bundled SDK updates arrive with NordRelay releases.");
+            }
+            return plan(agentId, "claude update", cli.path, ["update"], "Runs the Claude Code updater. Some package-manager installs may print a manual command instead.", env);
+        }
+    }
+}
+function plan(agentId, method, command, args, summary, env) {
+    return {
+        agentId,
+        agentLabel: agentLabel(agentId),
+        method,
+        command,
+        args,
+        cwd: env.HOME || os.homedir(),
+        summary,
+        interactive: true,
+    };
+}
+function looksLikePrompt(text) {
+    const tail = text.split(/\r?\n/).slice(-4).join("\n");
+    return /\b(y\/n|yes\/no|continue|proceed|confirm|password|passphrase|token|api key|enter|select)\b|[?>]\s*$/i.test(tail);
+}

package/dist/agent.js

@@ -1,4 +1,4 @@
-export const AGENT_IDS = ["codex", "pi"];
+export const AGENT_IDS = ["codex", "pi", "hermes", "openclaw", "claude-code"];
 export const CODEX_REASONING_EFFORTS = [
     "minimal",
     "low",
@@ -14,6 +14,29 @@ export const PI_THINKING_LEVELS = [
     "high",
     "xhigh",
 ];
+export const HERMES_REASONING_EFFORTS = [
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+];
+export const OPENCLAW_THINKING_LEVELS = [
+    "off",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+];
+export const CLAUDE_CODE_EFFORT_LEVELS = [
+    "off",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+];
 export const CODEX_AGENT_CAPABILITIES = {
     launchProfiles: true,
     fastMode: true,
@@ -23,6 +46,8 @@ export const CODEX_AGENT_CAPABILITIES = {
     auth: true,
     login: true,
     logout: true,
+    usageStats: true,
+    subscriptionLimits: true,
     usageLimits: true,
     workspaces: true,
     attachments: true,
@@ -31,14 +56,70 @@ export const CODEX_AGENT_CAPABILITIES = {
     handback: true,
 };
 export const PI_AGENT_CAPABILITIES = {
-    launchProfiles: false,
+    launchProfiles: true,
+    fastMode: false,
+    externalActivity: true,
+    cliMirror: true,
+    activityLog: true,
+    auth: true,
+    login: false,
+    logout: false,
+    usageStats: true,
+    subscriptionLimits: false,
+    usageLimits: false,
+    workspaces: true,
+    attachments: true,
+    modelSelection: true,
+    reasoningSelection: true,
+    handback: true,
+};
+export const HERMES_AGENT_CAPABILITIES = {
+    launchProfiles: true,
     fastMode: false,
-    externalActivity: false,
-    cliMirror: false,
-    activityLog: false,
-    auth: false,
+    externalActivity: true,
+    cliMirror: true,
+    activityLog: true,
+    auth: true,
+    login: true,
+    logout: true,
+    usageStats: true,
+    subscriptionLimits: false,
+    usageLimits: false,
+    workspaces: true,
+    attachments: true,
+    modelSelection: true,
+    reasoningSelection: true,
+    handback: true,
+};
+export const OPENCLAW_AGENT_CAPABILITIES = {
+    launchProfiles: true,
+    fastMode: false,
+    externalActivity: true,
+    cliMirror: true,
+    activityLog: true,
+    auth: true,
     login: false,
     logout: false,
+    usageStats: true,
+    subscriptionLimits: false,
+    usageLimits: false,
+    workspaces: true,
+    attachments: true,
+    modelSelection: true,
+    reasoningSelection: true,
+    handback: true,
+};
+export const CLAUDE_CODE_AGENT_CAPABILITIES = {
+    launchProfiles: true,
+    fastMode: false,
+    externalActivity: true,
+    cliMirror: true,
+    activityLog: true,
+    auth: true,
+    login: true,
+    logout: true,
+    usageStats: true,
+    subscriptionLimits: false,
     usageLimits: false,
     workspaces: true,
     attachments: true,
@@ -47,11 +128,44 @@ export const PI_AGENT_CAPABILITIES = {
     handback: true,
 };
 export function isAgentId(value) {
-    return value === "codex" || value === "pi";
+    return AGENT_IDS.includes(value);
 }
 export function agentLabel(agentId) {
-    return agentId === "pi" ? "Pi" : "Codex";
+    if (agentId === "pi") {
+        return "Pi";
+    }
+    if (agentId === "hermes") {
+        return "Hermes";
+    }
+    if (agentId === "openclaw") {
+        return "OpenClaw";
+    }
+    if (agentId === "claude-code") {
+        return "Claude Code";
+    }
+    return "Codex";
 }
 export function agentReasoningLabel(agentId) {
-    return agentId === "pi" ? "Thinking" : "Reasoning";
+    if (agentId === "pi" || agentId === "openclaw") {
+        return "Thinking";
+    }
+    if (agentId === "claude-code") {
+        return "Effort";
+    }
+    return "Reasoning";
+}
+export function agentReasoningOptions(agentId) {
+    if (agentId === "pi") {
+        return PI_THINKING_LEVELS;
+    }
+    if (agentId === "hermes") {
+        return HERMES_REASONING_EFFORTS;
+    }
+    if (agentId === "openclaw") {
+        return OPENCLAW_THINKING_LEVELS;
+    }
+    if (agentId === "claude-code") {
+        return CLAUDE_CODE_EFFORT_LEVELS;
+    }
+    return CODEX_REASONING_EFFORTS;
 }

package/dist/artifacts.js

@@ -178,7 +178,7 @@ export async function createArtifactZipBundle(artifacts, outDir, options = {}) {
     }
     const bundleDir = path.join(outDir, ".telegram-artifacts");
     await mkdir(bundleDir, { recursive: true });
-    const bundleName = options.bundleName ?? `codex-artifacts-${sanitizeZipStem(path.basename(path.dirname(outDir)))}.zip`;
+    const bundleName = options.bundleName ?? `nordrelay-artifacts-${sanitizeZipStem(path.basename(path.dirname(outDir)))}.zip`;
     const bundlePath = path.join(bundleDir, bundleName);
     await rm(bundlePath, { force: true }).catch(() => { });
     try {

package/dist/audit-log.js

@@ -17,8 +17,8 @@ export class AuditLogStore {
         const next = {
             id: randomUUID().replace(/-/g, "").slice(0, 12),
             timestamp: new Date().toISOString(),
-            channelId: "telegram",
             ...event,
+            channelId: event.channelId ?? "telegram",
         };
         payload.events.push(next);
         if (payload.events.length > this.maxEvents) {

package/dist/bot-ui.js

@@ -8,7 +8,7 @@ export function renderHelpMessage() {
             title: "💬 Session",
             commands: [
                 ["/new", "Start a new thread"],
-                ["/agent", "Select Codex or Pi"],
+                ["/agent", "Select agent"],
                 ["/session", "Current thread details"],
                 ["/sessions", "Browse & switch threads"],
                 ["/sync", "Sync active sessions from CLI state"],