@nordbyte/nordrelay 0.4.0 → 0.4.1

package/dist/channel-actions.js

@@ -0,0 +1,372 @@
+import { formatAgentFeatureSummaryHTML, formatAgentFeatureSummaryPlain } from "./agent-feature-matrix.js";
+import { totalArtifactSize } from "./artifacts.js";
+import { escapeHTML } from "./format.js";
+import { getAgentUpdateLogPath, getUpdateLogPath } from "./operations.js";
+import { formatFileSize } from "./session-format.js";
+export function renderChannelsAction(descriptors) {
+    const plain = [
+        "Channel adapters:",
+        ...descriptors.map((descriptor) => {
+            const status = descriptor.status === "available" ? "available" : "planned";
+            return `${descriptor.label}: ${status} · ${descriptor.capabilities.join(", ")}`;
+        }),
+    ].join("\n");
+    const html = [
+        "<b>Channel adapters:</b>",
+        ...descriptors.map((descriptor) => {
+            const statusIcon = descriptor.status === "available" ? "✅" : "🟡";
+            const notes = descriptor.notes ? `\n  ${escapeHTML(descriptor.notes)}` : "";
+            return `${statusIcon} <b>${escapeHTML(descriptor.label)}</b> <code>${escapeHTML(descriptor.status)}</code>\n  <code>${escapeHTML(descriptor.capabilities.join(", "))}</code>${notes}`;
+        }),
+    ].join("\n");
+    return { plain, html };
+}
+export function renderAgentsAction(descriptors, enabledAgents) {
+    const enabled = new Set(enabledAgents);
+    const plain = [
+        "Agent adapters:",
+        ...descriptors.flatMap((descriptor) => [
+            `${descriptor.label}: ${descriptor.status}${descriptor.status === "available" ? ` · ${enabled.has(descriptor.id) ? "enabled" : "disabled"}` : ""}`,
+            ...formatAgentFeatureSummaryPlain(descriptor.capabilities).map((line) => `  ${line}`),
+        ]),
+    ].join("\n");
+    const html = [
+        "<b>Agent adapters:</b>",
+        ...descriptors.map((descriptor) => {
+            const status = descriptor.status === "available" ? `${enabled.has(descriptor.id) ? "enabled" : "disabled"}` : "planned";
+            const notes = descriptor.notes ? `\n  ${escapeHTML(descriptor.notes)}` : "";
+            return [
+                `${descriptor.status === "available" ? "✅" : "🟡"} <b>${escapeHTML(descriptor.label)}</b> <code>${escapeHTML(status)}</code>${notes}`,
+                ...formatAgentFeatureSummaryHTML(descriptor.capabilities).map((line) => `  ${line}`),
+            ].join("\n");
+        }),
+    ].join("\n");
+    return { plain, html };
+}
+export function renderAgentUpdatePickerAction(descriptors) {
+    const available = descriptors.filter((descriptor) => descriptor.status === "available");
+    const buttons = available.map((descriptor) => [{ label: `Update ${descriptor.label}`, action: `agent-update:start:${descriptor.id}` }]);
+    buttons.push([{ label: "Show update jobs", action: "agent-update:jobs" }]);
+    return {
+        plain: [
+            "Agent updates:",
+            ...available.map((descriptor) => `${descriptor.label}: /update ${descriptor.id}`),
+            "",
+            "Use /update jobs to list running and recent agent updates.",
+        ].join("\n"),
+        html: [
+            "<b>Agent updates:</b>",
+            ...available.map((descriptor) => `<b>${escapeHTML(descriptor.label)}:</b> <code>/update ${escapeHTML(descriptor.id)}</code>`),
+            "",
+            "Use <code>/update jobs</code> to list running and recent agent updates.",
+        ].join("\n"),
+        buttons,
+    };
+}
+export function parseAgentUpdateId(value) {
+    const normalized = value?.toLowerCase();
+    if (!normalized) {
+        return null;
+    }
+    if (normalized === "claude") {
+        return "claude-code";
+    }
+    return ["codex", "pi", "hermes", "openclaw", "claude-code"].includes(normalized)
+        ? normalized
+        : null;
+}
+export function renderAgentUpdateJobsAction(jobs) {
+    if (jobs.length === 0) {
+        return {
+            plain: "No agent update jobs yet. Use /update agents to start one.",
+            html: "No agent update jobs yet. Use <code>/update agents</code> to start one.",
+        };
+    }
+    const limited = jobs.slice(0, 10);
+    return {
+        plain: [
+            "Agent update jobs:",
+            ...limited.map((job) => `${job.id}: ${job.agentLabel} · ${job.status} · ${formatLocalDateTime(new Date(job.updatedAt))}`),
+            "",
+            "Use /update log <id>, /update cancel <id>, or /update input <id> <text>.",
+        ].join("\n"),
+        html: [
+            "<b>Agent update jobs:</b>",
+            ...limited.map((job) => `<code>${escapeHTML(job.id)}</code> ${escapeHTML(job.agentLabel)} · <b>${escapeHTML(job.status)}</b> · <code>${escapeHTML(formatLocalDateTime(new Date(job.updatedAt)))}</code>`),
+            "",
+            "Use <code>/update log &lt;id&gt;</code>, <code>/update cancel &lt;id&gt;</code>, or <code>/update input &lt;id&gt; &lt;text&gt;</code>.",
+        ].join("\n"),
+    };
+}
+export function renderAgentUpdateJobAction(job) {
+    const command = [job.command, ...job.args].join(" ");
+    const inputLine = job.canInput
+        ? `If the updater asks a question, reply with /update input ${job.id} <text>.`
+        : "This update job is no longer accepting input.";
+    const tail = trimLine(job.outputTail || "(waiting for output)", 1200);
+    return {
+        plain: [
+            `${job.agentLabel} update ${job.status}.`,
+            `ID: ${job.id}`,
+            `Method: ${job.method}`,
+            `Command: ${command}`,
+            `Started: ${formatLocalDateTime(new Date(job.startedAt))}`,
+            job.finishedAt ? `Finished: ${formatLocalDateTime(new Date(job.finishedAt))}` : undefined,
+            job.error ? `Error: ${job.error}` : undefined,
+            `Log: ${job.logPath}`,
+            `Agent update log: ${getAgentUpdateLogPath()}`,
+            inputLine,
+            "",
+            tail,
+        ].filter(Boolean).join("\n"),
+        html: [
+            `<b>${escapeHTML(job.agentLabel)} update ${escapeHTML(job.status)}.</b>`,
+            `<b>ID:</b> <code>${escapeHTML(job.id)}</code>`,
+            `<b>Method:</b> <code>${escapeHTML(job.method)}</code>`,
+            `<b>Command:</b> <code>${escapeHTML(command)}</code>`,
+            `<b>Started:</b> <code>${escapeHTML(formatLocalDateTime(new Date(job.startedAt)))}</code>`,
+            job.finishedAt ? `<b>Finished:</b> <code>${escapeHTML(formatLocalDateTime(new Date(job.finishedAt)))}</code>` : undefined,
+            job.error ? `<b>Error:</b> ${escapeHTML(job.error)}` : undefined,
+            `<b>Log:</b> <code>${escapeHTML(job.logPath)}</code>`,
+            `<b>Agent update log:</b> <code>${escapeHTML(getAgentUpdateLogPath())}</code>`,
+            escapeHTML(inputLine),
+            "",
+            `<pre>${escapeHTML(tail)}</pre>`,
+        ].filter(Boolean).join("\n"),
+        buttons: [
+            [
+                { label: "Full log", action: `agent-update:log:${job.id}` },
+                ...(job.canInput ? [{ label: "Cancel", action: `agent-update:cancel:${job.id}` }] : []),
+            ],
+        ],
+    };
+}
+export function renderAgentUpdateLogAction(result) {
+    const tail = trimLine(result.plain || "(empty)", 3000);
+    return {
+        plain: [
+            `${result.job.agentLabel} update log`,
+            `ID: ${result.job.id}`,
+            `Status: ${result.job.status}`,
+            `File: ${result.job.logPath}`,
+            "",
+            tail,
+        ].join("\n"),
+        html: [
+            `<b>${escapeHTML(result.job.agentLabel)} update log</b>`,
+            `<b>ID:</b> <code>${escapeHTML(result.job.id)}</code>`,
+            `<b>Status:</b> <code>${escapeHTML(result.job.status)}</code>`,
+            `<b>File:</b> <code>${escapeHTML(result.job.logPath)}</code>`,
+            "",
+            `<pre>${escapeHTML(tail)}</pre>`,
+        ].join("\n"),
+    };
+}
+export function renderSelfUpdateStartedAction(update) {
+    return {
+        plain: [
+            "Update started.",
+            `Method: ${update.method}`,
+            update.summary,
+            `Source: ${update.sourceRoot}`,
+            `Log: ${update.logPath}`,
+            "Use /logs update after the restart or inspect update.log on the host.",
+            "Use /update agents for agent CLI updates.",
+        ].join("\n"),
+        html: [
+            "<b>Update started.</b>",
+            `<b>Method:</b> <code>${escapeHTML(update.method)}</code>`,
+            escapeHTML(update.summary),
+            `<b>Source:</b> <code>${escapeHTML(update.sourceRoot)}</code>`,
+            `<b>Log:</b> <code>${escapeHTML(update.logPath)}</code>`,
+            `Use <code>/logs update</code> after the restart or inspect <code>${escapeHTML(getUpdateLogPath())}</code> on the host.`,
+            "Use <code>/update agents</code> for agent CLI updates.",
+        ].join("\n"),
+    };
+}
+export function parseLogsCommand(argument) {
+    const tokens = argument.split(/\s+/).filter(Boolean);
+    let target = "connector";
+    let lines = 80;
+    for (const token of tokens) {
+        const normalized = token.toLowerCase();
+        if (normalized === "connector" || normalized === "main") {
+            target = "connector";
+            continue;
+        }
+        if (normalized === "update" || normalized === "self-update" || normalized === "self") {
+            target = "update";
+            continue;
+        }
+        if (normalized === "agent" || normalized === "agents" || normalized === "agent-update" || normalized === "agent-updates") {
+            target = "agent-updates";
+            continue;
+        }
+        if (normalized === "all") {
+            target = "all";
+            continue;
+        }
+        const parsedLines = Number.parseInt(token, 10);
+        if (!Number.isNaN(parsedLines)) {
+            lines = parsedLines;
+        }
+    }
+    return { target, lines };
+}
+export function logTailRequests(target) {
+    if (target === "all") {
+        return [
+            { title: "Connector" },
+            { title: "Update", path: getUpdateLogPath() },
+            { title: "Agent updates", path: getAgentUpdateLogPath() },
+        ];
+    }
+    return [{ title: logTargetTitle(target), path: logTargetPath(target) }];
+}
+export function renderLogTailsAction(logs) {
+    return {
+        plain: logs.map(({ title, tail }) => renderLogTailPlain(title, tail)).join("\n\n"),
+        html: logs.map(({ title, tail }) => renderLogTailHTML(title, tail)).join("\n\n"),
+    };
+}
+export function renderArtifactReportsAction(reports) {
+    const lines = reports.slice(0, 5).map((report, index) => {
+        const size = formatFileSize(totalArtifactSize(report.artifacts));
+        const skipped = report.skippedCount > 0 ? `, ${report.skippedCount} skipped` : "";
+        return `${index + 1}. ${report.turnId} · ${formatRelativeTime(report.updatedAt)} · ${report.artifacts.length} file${report.artifacts.length === 1 ? "" : "s"} · ${size}${skipped}`;
+    });
+    const usage = "Tap an action below, or use /artifacts latest, /artifacts zip latest, /artifacts images, /artifacts docs, /artifacts search <text>, or /artifacts delete <turn-id>.";
+    return {
+        plain: ["Recent artifacts:", ...lines, "", usage].join("\n"),
+        html: ["<b>Recent artifacts:</b>", ...lines.map(escapeHTML), "", escapeHTML(usage)].join("\n"),
+    };
+}
+export function renderQueueListAction(queue, paused) {
+    if (queue.length === 0) {
+        return {
+            plain: paused ? "Queue is empty and paused." : "Queue is empty.",
+            html: escapeHTML(paused ? "Queue is empty and paused." : "Queue is empty."),
+        };
+    }
+    const lines = queue.map((item, index) => {
+        const age = formatRelativeTime(new Date(item.createdAt));
+        const attempts = item.attempts && item.attempts > 0 ? ` · attempts ${item.attempts}` : "";
+        const error = item.lastError ? ` · last error: ${trimLine(item.lastError, 80)}` : "";
+        const scheduled = item.notBefore && item.notBefore > Date.now()
+            ? `scheduled ${formatLocalDateTime(new Date(item.notBefore))}`
+            : index === 0 ? "next" : `after ${index} queued item${index === 1 ? "" : "s"}`;
+        return `${index + 1}. ${item.id} · ${age} · ${scheduled}${attempts}${error} · ${item.description}`;
+    });
+    return {
+        plain: [paused ? "Queued prompts (paused):" : "Queued prompts:", ...lines].join("\n"),
+        html: [paused ? "<b>Queued prompts:</b> <code>paused</code>" : "<b>Queued prompts:</b>", ...lines.map(escapeHTML)].join("\n"),
+    };
+}
+export function renderQueuedPromptDetailAction(item) {
+    const lines = [
+        "Queued prompt:",
+        `ID: ${item.id}`,
+        `Created: ${formatLocalDateTime(new Date(item.createdAt))}`,
+        item.notBefore ? `Scheduled: ${formatLocalDateTime(new Date(item.notBefore))}` : undefined,
+        `Attempts: ${item.attempts ?? 0}`,
+        item.lastError ? `Last error: ${item.lastError}` : undefined,
+        `Description: ${item.description}`,
+    ].filter((line) => Boolean(line));
+    return {
+        plain: lines.join("\n"),
+        html: [
+            "<b>Queued prompt:</b>",
+            `<b>ID:</b> <code>${escapeHTML(item.id)}</code>`,
+            `<b>Created:</b> <code>${escapeHTML(formatLocalDateTime(new Date(item.createdAt)))}</code>`,
+            item.notBefore ? `<b>Scheduled:</b> <code>${escapeHTML(formatLocalDateTime(new Date(item.notBefore)))}</code>` : undefined,
+            `<b>Attempts:</b> <code>${item.attempts ?? 0}</code>`,
+            item.lastError ? `<b>Last error:</b> ${escapeHTML(item.lastError)}` : undefined,
+            `<b>Description:</b> ${escapeHTML(item.description)}`,
+        ].filter((line) => Boolean(line)).join("\n"),
+    };
+}
+function logTargetTitle(target) {
+    if (target === "update") {
+        return "Update";
+    }
+    if (target === "agent-updates") {
+        return "Agent updates";
+    }
+    return "Connector";
+}
+function logTargetPath(target) {
+    if (target === "update") {
+        return getUpdateLogPath();
+    }
+    if (target === "agent-updates") {
+        return getAgentUpdateLogPath();
+    }
+    return undefined;
+}
+function renderLogTailPlain(title, tail) {
+    return [
+        `${title} log tail`,
+        `File: ${tail.filePath}`,
+        `Updated: ${tail.updatedAt ? formatLocalDateTime(tail.updatedAt) : "-"}`,
+        `Lines: ${tail.lineCount}/${tail.requestedLines}`,
+        "",
+        tail.plain || "(empty)",
+    ].join("\n");
+}
+function renderLogTailHTML(title, tail) {
+    const body = tail.plain
+        ? tail.plain.split("\n").map(renderLogLineHTML).join("\n")
+        : "<code>(empty)</code>";
+    return [
+        `<b>${escapeHTML(title)} log tail</b>`,
+        `<b>File:</b> <code>${escapeHTML(tail.filePath)}</code>`,
+        `<b>Updated:</b> <code>${escapeHTML(tail.updatedAt ? formatLocalDateTime(tail.updatedAt) : "-")}</code>`,
+        `<b>Lines:</b> <code>${tail.lineCount}/${tail.requestedLines}</code>`,
+        "",
+        body,
+    ].join("\n");
+}
+function renderLogLineHTML(line) {
+    const structured = line.match(/^(?<timestamp>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}|unknown time\s*)\s+(?<level>INFO|WARN|ERROR)\s+(?<message>.*)$/);
+    if (structured?.groups) {
+        const level = structured.groups.level;
+        const levelHtml = level === "INFO" ? escapeHTML(level) : `<b>${escapeHTML(level)}</b>`;
+        return [
+            `<code>${escapeHTML(structured.groups.timestamp.trim())}</code>`,
+            levelHtml,
+            escapeHTML(structured.groups.message),
+        ].join(" ");
+    }
+    return escapeHTML(line);
+}
+function formatLocalDateTime(date) {
+    if (Number.isNaN(date.getTime())) {
+        return "-";
+    }
+    return [
+        `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`,
+        `${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())}`,
+    ].join(" ");
+}
+function formatRelativeTime(date) {
+    const seconds = Math.max(0, Math.round((Date.now() - date.getTime()) / 1000));
+    if (seconds < 60) {
+        return `${seconds}s ago`;
+    }
+    const minutes = Math.round(seconds / 60);
+    if (minutes < 60) {
+        return `${minutes}m ago`;
+    }
+    const hours = Math.round(minutes / 60);
+    if (hours < 24) {
+        return `${hours}h ago`;
+    }
+    return `${Math.round(hours / 24)}d ago`;
+}
+function trimLine(text, maxLength) {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    return normalized.length > maxLength ? `${normalized.slice(0, Math.max(0, maxLength - 3))}...` : normalized;
+}
+function pad2(value) {
+    return String(value).padStart(2, "0");
+}

package/dist/operations.js

@@ -12,7 +12,8 @@ import { describePiCli, resolvePiCli } from "./pi-cli.js";
 const APP_NAME = "nordrelay";
 const PACKAGE_NAME = "@nordbyte/nordrelay";
 const CODEX_PACKAGE_NAME = "@openai/codex";
-const PI_PACKAGE_NAME = "@mariozechner/pi-coding-agent";
+const PI_PACKAGE_NAME = "@earendil-works/pi-coding-agent";
+const LEGACY_PI_PACKAGE_NAME = "@mariozechner/pi-coding-agent";
 const HERMES_PACKAGE_NAME = "hermes-agent";
 const OPENCLAW_PACKAGE_NAME = "openclaw";
 const CLAUDE_CODE_PACKAGE_NAME = "@anthropic-ai/claude-code";
@@ -32,6 +33,9 @@ export function getConnectorLogPath() {
 export function getUpdateLogPath() {
     return path.join(getConnectorHome(), "update.log");
 }
+export function getAgentUpdateLogPath(home = getConnectorHome()) {
+    return path.join(home, "agent-updates.log");
+}
 export async function readConnectorState() {
     try {
         return JSON.parse(await readFile(getConnectorStatePath(), "utf8"));
@@ -74,6 +78,14 @@ export async function readFormattedLogTail(lines = 80, filePath = getConnectorLo
         };
     }
 }
+export function clearLogFile(filePath = getConnectorLogPath()) {
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    writeFileSync(filePath, "", "utf8");
+    return {
+        filePath,
+        clearedAt: new Date(),
+    };
+}
 export async function getPackageVersion() {
     try {
         const pkg = JSON.parse(await readFile(path.join(getSourceRoot(), "package.json"), "utf8"));
@@ -93,7 +105,10 @@ export async function getVersionChecks(options = {}) {
     const codexVersionLabel = codexCli.path
         ? detectCliVersion(codexCli.path)
         : readInstalledPackageVersion(CODEX_PACKAGE_NAME) ?? "not installed";
-    const piVersionLabel = piCli.path ? detectCliVersion(piCli.path) : "not installed";
+    const piVersionLabel = piCli.path
+        ? detectCliVersion(piCli.path)
+        : readInstalledPackageVersion(PI_PACKAGE_NAME) ?? readInstalledPackageVersion(LEGACY_PI_PACKAGE_NAME) ?? "not installed";
+    const legacyPiPackageVersion = readInstalledPackageVersion(LEGACY_PI_PACKAGE_NAME);
     const hermesVersionLabel = hermesCli.path ? detectCliVersion(hermesCli.path) : "not installed";
     const openClawVersionLabel = openClawCli.path ? detectCliVersion(openClawCli.path) : "not installed";
     const claudeCodeVersionLabel = claudeCodeCli.path
@@ -120,6 +135,7 @@ export async function getVersionChecks(options = {}) {
             installedLabel: piVersionLabel,
             installedVersion: extractVersion(piVersionLabel),
             notInstalled: piVersionLabel === "not installed",
+            detail: legacyPiPackageVersion ? `Legacy package ${LEGACY_PI_PACKAGE_NAME} is present; current package is ${PI_PACKAGE_NAME}.` : undefined,
         }),
         hermes: buildHermesVersionCheck(hermesVersionLabel),
         openclaw: buildVersionCheck({
@@ -139,10 +155,11 @@ export async function getVersionChecks(options = {}) {
     };
 }
 export async function getConnectorHealth(options = {}) {
-    const state = await readConnectorState();
+    const rawState = await readConnectorState();
     const version = await getPackageVersion();
-    const pidRunning = isProcessRunning(state.pid);
-    const appPidRunning = isProcessRunning(state.appPid);
+    const pidRunning = isProcessRunning(rawState.pid);
+    const appPidRunning = isProcessRunning(rawState.appPid);
+    const state = normalizeConnectorState(rawState, pidRunning, appPidRunning);
     const codexCli = resolveCodexCli();
     const piCli = resolvePiCli(process.env, options.piCliPath);
     const hermesCli = resolveHermesCli(process.env, options.hermesCliPath);
@@ -247,6 +264,13 @@ function isProcessRunning(pid) {
         return false;
     }
 }
+function normalizeConnectorState(state, pidRunning, appPidRunning) {
+    const stoppedSignal = state.signal === "SIGTERM" || state.signal === "SIGINT";
+    if (state.status === "error" && stoppedSignal && !state.error && !pidRunning && !appPidRunning) {
+        return { ...state, status: "stopped" };
+    }
+    return state;
+}
 function redactSecrets(text) {
     return text.replace(SECRET_RE, "$1$2[redacted]");
 }
@@ -328,6 +352,7 @@ function buildVersionCheck(options) {
             installedVersion: null,
             latestVersion: null,
             status: "not-installed",
+            detail: options.detail,
         };
     }
     if (options.skipLatest) {
@@ -338,7 +363,7 @@ function buildVersionCheck(options) {
             installedVersion: options.installedVersion,
             latestVersion: null,
             status: options.installedVersion ? "unknown" : "unknown",
-            detail: "Latest-version lookup is not available for this package source",
+            detail: options.detail ?? "Latest-version lookup is not available for this package source",
         };
     }
     const latest = detectLatestNpmVersion(options.packageName);
@@ -350,7 +375,7 @@ function buildVersionCheck(options) {
             installedVersion: options.installedVersion,
             latestVersion: latest.version,
             status: "unknown",
-            detail: latest.error ?? "Could not parse installed version",
+            detail: [options.detail, latest.error ?? "Could not parse installed version"].filter(Boolean).join(" "),
         };
     }
     return {
@@ -360,7 +385,7 @@ function buildVersionCheck(options) {
         installedVersion: options.installedVersion,
         latestVersion: latest.version,
         status: compareVersions(options.installedVersion, latest.version) < 0 ? "outdated" : "current",
-        detail: latest.error,
+        detail: [options.detail, latest.error].filter(Boolean).join(" ") || undefined,
     };
 }
 function detectLatestNpmVersion(packageName) {