@nordbyte/nordrelay 0.4.0 → 0.4.1

package/dist/bot.js

@@ -8,9 +8,11 @@ import { hasTelegramPermission, permissionForCallbackData, permissionForCommand,
 import { buildFileInstructions, outboxPath, stageFile, } from "./attachments.js";
 import { collectArtifactReport, collectRecentWorkspaceArtifacts, createArtifactZipBundle, ensureOutDir, formatArtifactSummary, getArtifactTurnReport, isTelegramImagePreview, listRecentArtifactReports, persistWorkspaceArtifactReport, pruneConnectorTurnDirs, removeArtifactTurn, telegramArtifactFilename, totalArtifactSize, } from "./artifacts.js";
 import { listAgentAdapterDescriptors } from "./agent-adapter.js";
+import { AgentUpdateManager } from "./agent-updates.js";
 import { AuditLogStore } from "./audit-log.js";
 import { formatSessionLabel, renderHelpMessage, renderWelcomeFirstTime, renderWelcomeReturning, } from "./bot-ui.js";
 import { BotPreferencesStore, formatQuietHours, isQuietNow, parseMirrorMode, parseNotifyMode, parseQuietHours, parseVoiceBackendPreference, } from "./bot-preferences.js";
+import { logTailRequests, parseAgentUpdateId, parseLogsCommand, renderAgentUpdateJobAction, renderAgentUpdateJobsAction, renderAgentUpdateLogAction, renderAgentUpdatePickerAction, renderAgentsAction, renderArtifactReportsAction, renderChannelsAction, renderLogTailsAction, renderQueueListAction, renderQueuedPromptDetailAction, renderSelfUpdateStartedAction, } from "./channel-actions.js";
 import { listChannelDescriptors } from "./channel-adapter.js";
 import { CODEX_AGENT_CAPABILITIES, agentLabel, agentReasoningLabel, agentReasoningOptions, } from "./agent.js";
 import { getAgentActivityLog, getAgentDiagnostics, getExternalActivityForSession, getExternalSnapshotForSession, } from "./agent-activity.js";
@@ -21,14 +23,14 @@ import { formatLaunchProfileBehavior } from "./codex-launch.js";
 import { contextKeyFromCtx, isTelegramContextKey, isTopicContextKey, parseContextKey } from "./context-key.js";
 import { friendlyErrorText } from "./error-messages.js";
 import { escapeHTML, formatTelegramHTML } from "./format.js";
-import { getConnectorHealth, getUpdateLogPath, getVersionChecks, readConnectorState, readFormattedLogTail, spawnConnectorRestart, spawnSelfUpdate, } from "./operations.js";
+import { getConnectorHealth, getVersionChecks, readConnectorState, readFormattedLogTail, spawnConnectorRestart, spawnSelfUpdate, } from "./operations.js";
 import { PromptStore, toPromptEnvelope } from "./prompt-store.js";
 import { checkHermesAuthStatus, startHermesLogin, startHermesLogout } from "./hermes-auth.js";
 import { checkOpenClawAuthStatus } from "./openclaw-auth.js";
 import { checkPiAuthStatus } from "./pi-auth.js";
 import { configureRedaction, redactText } from "./redaction.js";
 import { canWriteWithLock, SessionLockStore } from "./session-locks.js";
-import { formatFileSize, renderLaunchSummaryHTML, renderLaunchSummaryPlain, renderSessionInfoHTML, renderSessionInfoPlain, } from "./session-format.js";
+import { renderLaunchSummaryHTML, renderLaunchSummaryPlain, renderSessionInfoHTML, renderSessionInfoPlain, } from "./session-format.js";
 import { SessionRegistry } from "./session-registry.js";
 import { getAvailableBackends, transcribeAudio } from "./voice.js";
 import { getTelegramRateLimitMetrics, telegramRateLimiter } from "./telegram-rate-limit.js";
@@ -67,6 +69,37 @@ function paginateKeyboard(items, page, prefix) {
     }
     return keyboard;
 }
+function actionKeyboard(rows) {
+    if (!rows || rows.length === 0) {
+        return undefined;
+    }
+    const keyboard = new InlineKeyboard();
+    for (const row of rows) {
+        for (const button of row) {
+            keyboard.text(button.label, telegramActionData(button.action));
+        }
+        keyboard.row();
+    }
+    return keyboard;
+}
+function telegramActionData(action) {
+    if (action === "agent-update:jobs") {
+        return "upd_jobs";
+    }
+    const agentUpdateStart = action.match(/^agent-update:start:(.+)$/);
+    if (agentUpdateStart?.[1]) {
+        return `upd_agent:${agentUpdateStart[1]}`;
+    }
+    const agentUpdateLog = action.match(/^agent-update:log:(.+)$/);
+    if (agentUpdateLog?.[1]) {
+        return `upd_log:${agentUpdateLog[1]}`;
+    }
+    const agentUpdateCancel = action.match(/^agent-update:cancel:(.+)$/);
+    if (agentUpdateCancel?.[1]) {
+        return `upd_cancel:${agentUpdateCancel[1]}`;
+    }
+    return action;
+}
 export function createBot(config, registry) {
     configureRedaction(config.telegramRedactPatterns);
     telegramRateLimiter.configure({
@@ -94,6 +127,7 @@ export function createBot(config, registry) {
     const preferencesStore = new BotPreferencesStore(config.workspace, config.stateBackend);
     const auditLog = new AuditLogStore(config.workspace, config.stateBackend, config.auditMaxEvents);
     const lockStore = new SessionLockStore(config.workspace, config.stateBackend);
+    const agentUpdates = new AgentUpdateManager();
     const drainingQueues = new Set();
     const externalQueueTimers = new Map();
     const externalMirrors = new Map();
@@ -220,6 +254,37 @@ export function createBot(config, registry) {
         }
         return checkAuthStatus(config.codexApiKey);
     };
+    const agentUpdateContext = () => ({
+        piCliPath: config.piCliPath,
+        hermesCliPath: config.hermesCliPath,
+        openClawCliPath: config.openClawCliPath,
+        claudeCodeCliPath: config.claudeCodeCliPath,
+    });
+    const startTelegramAgentUpdate = async (ctx, agentId) => {
+        try {
+            const job = agentUpdates.start(agentId, agentUpdateContext());
+            const contextKey = contextKeyFromCtx(ctx);
+            if (contextKey) {
+                audit({
+                    action: "command",
+                    status: "ok",
+                    contextKey,
+                    agentId,
+                    description: `update ${agentId}`,
+                    detail: job.summary,
+                });
+            }
+            const rendered = renderAgentUpdateJobAction(job);
+            await safeReply(ctx, rendered.html, {
+                fallbackText: rendered.plain,
+                replyMarkup: actionKeyboard(rendered.buttons),
+            });
+        }
+        catch (error) {
+            const message = `Failed to start ${agentLabel(agentId)} update: ${friendlyErrorText(error)}`;
+            await safeReply(ctx, `<b>Update failed:</b> ${escapeHTML(message)}`, { fallbackText: message });
+        }
+    };
     const startAgentLogin = (info) => {
         const agentId = agentIdForAuth(info);
         if (agentId === "hermes") {
@@ -324,22 +389,10 @@ export function createBot(config, registry) {
     const createQueuedPromptCancelKeyboard = (contextKey, queueId, label = "Cancel queued message") => new InlineKeyboard().text(label, queueCancelCallbackData("cancel", contextKey, queueId));
     const renderQueueList = (contextKey, queue) => {
         const paused = promptStore.isPaused(contextKey);
+        const rendered = 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."),
-            };
+            return rendered;
         }
-        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"}`;
-            const eta = scheduled;
-            return `${index + 1}. ${item.id} · ${age} · ${eta}${attempts}${error} · ${item.description}`;
-        });
         const keyboard = new InlineKeyboard();
         queue.forEach((item, index) => {
             keyboard
@@ -352,11 +405,7 @@ export function createBot(config, registry) {
                 .text("Down", queueCancelCallbackData("down", contextKey, item.id))
                 .row();
         });
-        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"),
-            keyboard,
-        };
+        return { ...rendered, keyboard };
     };
     const createSystemContext = (contextKey) => {
         const parsed = parseContextKey(contextKey);
@@ -1629,60 +1678,12 @@ export function createBot(config, registry) {
         await safeReply(ctx, help.html, { fallbackText: help.plain });
     });
     bot.command("channels", async (ctx) => {
-        const descriptors = listChannelDescriptors();
-        const lines = descriptors.map((descriptor) => {
-            const status = descriptor.status === "available" ? "available" : "planned";
-            return `${descriptor.label}: ${status} · ${descriptor.capabilities.join(", ")}`;
-        });
-        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");
-        await safeReply(ctx, html, { fallbackText: ["Channel adapters:", ...lines].join("\n") });
+        const rendered = renderChannelsAction(listChannelDescriptors());
+        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
     });
     bot.command("agents", async (ctx) => {
-        const descriptors = listAgentAdapterDescriptors();
-        const plain = [
-            "Agent adapters:",
-            ...descriptors.map((descriptor) => {
-                const enabled = descriptor.id === "codex"
-                    ? config.codexEnabled
-                    : descriptor.id === "pi"
-                        ? config.piEnabled
-                        : descriptor.id === "hermes"
-                            ? config.hermesEnabled
-                            : descriptor.id === "openclaw"
-                                ? config.openClawEnabled
-                                : descriptor.id === "claude-code"
-                                    ? config.claudeCodeEnabled
-                                    : false;
-                return `${descriptor.label}: ${descriptor.status}${descriptor.status === "available" ? ` · ${enabled ? "enabled" : "disabled"}` : ""}`;
-            }),
-        ].join("\n");
-        const html = [
-            "<b>Agent adapters:</b>",
-            ...descriptors.map((descriptor) => {
-                const enabled = descriptor.id === "codex"
-                    ? config.codexEnabled
-                    : descriptor.id === "pi"
-                        ? config.piEnabled
-                        : descriptor.id === "hermes"
-                            ? config.hermesEnabled
-                            : descriptor.id === "openclaw"
-                                ? config.openClawEnabled
-                                : descriptor.id === "claude-code"
-                                    ? config.claudeCodeEnabled
-                                    : false;
-                const status = descriptor.status === "available" ? `${enabled ? "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}`;
-            }),
-        ].join("\n");
-        await safeReply(ctx, html, { fallbackText: plain });
+        const rendered = renderAgentsAction(listAgentAdapterDescriptors(), enabledAgents(config));
+        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
     });
     bot.command("agent", async (ctx) => {
         const contextSession = await getContextSession(ctx, { deferThreadStart: true });
@@ -2244,20 +2245,12 @@ export function createBot(config, registry) {
         const rawText = ctx.message?.text ?? "";
         const argument = rawText.replace(/^\/logs(?:@\w+)?\s*/i, "").trim();
         const logRequest = parseLogsCommand(argument);
-        const logs = logRequest.target === "all"
-            ? [
-                { title: "Connector", tail: await readFormattedLogTail(logRequest.lines) },
-                { title: "Update", tail: await readFormattedLogTail(logRequest.lines, getUpdateLogPath()) },
-            ]
-            : [
-                {
-                    title: logRequest.target === "update" ? "Update" : "Connector",
-                    tail: await readFormattedLogTail(logRequest.lines, logRequest.target === "update" ? getUpdateLogPath() : undefined),
-                },
-            ];
-        const plain = logs.map(({ title, tail }) => renderLogTailPlain(title, tail)).join("\n\n");
-        const html = logs.map(({ title, tail }) => renderLogTailHTML(title, tail)).join("\n\n");
-        await safeReply(ctx, html, { fallbackText: plain });
+        const logs = await Promise.all(logTailRequests(logRequest.target).map(async (request) => ({
+            title: request.title,
+            tail: await readFormattedLogTail(logRequest.lines, request.path),
+        })));
+        const rendered = renderLogTailsAction(logs);
+        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
     });
     bot.command("restart", async (ctx) => {
         await safeReply(ctx, escapeHTML("Restarting connector..."), {
@@ -2268,24 +2261,92 @@ export function createBot(config, registry) {
         }, 300);
     });
     bot.command("update", async (ctx) => {
+        const rawText = ctx.message?.text ?? "";
+        const argument = rawText.replace(/^\/update(?:@\w+)?\s*/i, "").trim();
+        const tokens = argument.split(/\s+/).filter(Boolean);
+        const subcommand = tokens[0]?.toLowerCase();
+        if (subcommand === "agents" || subcommand === "agent") {
+            const rendered = renderAgentUpdatePickerAction(listAgentAdapterDescriptors());
+            await safeReply(ctx, rendered.html, { fallbackText: rendered.plain, replyMarkup: actionKeyboard(rendered.buttons) });
+            return;
+        }
+        if (subcommand === "jobs" || subcommand === "status") {
+            const rendered = renderAgentUpdateJobsAction(agentUpdates.list());
+            await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
+            return;
+        }
+        if (subcommand === "log" && tokens[1]) {
+            const rendered = renderAgentUpdateLogAction(agentUpdates.readLog(tokens[1]));
+            await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
+            return;
+        }
+        if (subcommand === "cancel" && tokens[1]) {
+            const job = agentUpdates.cancel(tokens[1]);
+            const rendered = renderAgentUpdateJobAction(job);
+            await safeReply(ctx, rendered.html, {
+                fallbackText: rendered.plain,
+                replyMarkup: actionKeyboard(rendered.buttons),
+            });
+            return;
+        }
+        if ((subcommand === "input" || subcommand === "send") && tokens[1] && tokens.slice(2).join(" ").trim()) {
+            const job = agentUpdates.sendInput(tokens[1], tokens.slice(2).join(" "));
+            const rendered = renderAgentUpdateJobAction(job);
+            await safeReply(ctx, rendered.html, {
+                fallbackText: rendered.plain,
+                replyMarkup: actionKeyboard(rendered.buttons),
+            });
+            return;
+        }
+        const requestedAgent = parseAgentUpdateId(subcommand);
+        if (requestedAgent) {
+            await startTelegramAgentUpdate(ctx, requestedAgent);
+            return;
+        }
+        if (subcommand) {
+            const usage = "Unknown update target. Use /update, /update agents, /update jobs, /update <agent>, /update log <id>, /update cancel <id>, or /update input <id> <text>.";
+            await safeReply(ctx, escapeHTML(usage), { fallbackText: usage });
+            return;
+        }
         const update = spawnSelfUpdate();
-        const 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.",
-        ].join("\n");
-        const 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.`,
-        ].join("\n");
-        await safeReply(ctx, html, { fallbackText: plain });
+        const rendered = renderSelfUpdateStartedAction(update);
+        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
+    });
+    bot.callbackQuery("upd_jobs", async (ctx) => {
+        await ctx.answerCallbackQuery();
+        const rendered = renderAgentUpdateJobsAction(agentUpdates.list());
+        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
+    });
+    bot.callbackQuery(/^upd_agent:(codex|pi|hermes|openclaw|claude-code)$/, async (ctx) => {
+        const agentId = ctx.match?.[1];
+        if (!agentId) {
+            await ctx.answerCallbackQuery();
+            return;
+        }
+        await ctx.answerCallbackQuery({ text: `Starting ${agentLabel(agentId)} update...` });
+        await startTelegramAgentUpdate(ctx, agentId);
+    });
+    bot.callbackQuery(/^upd_log:(.+)$/, async (ctx) => {
+        const id = ctx.match?.[1];
+        await ctx.answerCallbackQuery();
+        if (!id) {
+            return;
+        }
+        const rendered = renderAgentUpdateLogAction(agentUpdates.readLog(id));
+        await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
+    });
+    bot.callbackQuery(/^upd_cancel:(.+)$/, async (ctx) => {
+        const id = ctx.match?.[1];
+        await ctx.answerCallbackQuery({ text: "Cancelling update..." });
+        if (!id) {
+            return;
+        }
+        const job = agentUpdates.cancel(id);
+        const rendered = renderAgentUpdateJobAction(job);
+        await safeReply(ctx, rendered.html, {
+            fallbackText: rendered.plain,
+            replyMarkup: actionKeyboard(rendered.buttons),
+        });
     });
     bot.command("new", async (ctx) => {
         const chatId = ctx.chat?.id;
@@ -2433,7 +2494,7 @@ export function createBot(config, registry) {
                 });
                 return;
             }
-            const rendered = renderQueuedPromptDetail(item);
+            const rendered = renderQueuedPromptDetailAction(item);
             await safeReply(ctx, rendered.html, { fallbackText: rendered.plain });
             return;
         }
@@ -2591,7 +2652,7 @@ export function createBot(config, registry) {
                     });
                     return;
                 }
-                const rendered = renderArtifactReports(filtered);
+                const rendered = renderArtifactReportsAction(filtered);
                 await safeReply(ctx, rendered.html, {
                     fallbackText: rendered.plain,
                     replyMarkup: buildArtifactActionsKeyboard(filtered),
@@ -2617,7 +2678,7 @@ export function createBot(config, registry) {
             }
             return;
         }
-        const { html, plain } = renderArtifactReports(reports);
+        const { html, plain } = renderArtifactReportsAction(reports);
         await safeReply(ctx, html, {
             fallbackText: plain,
             replyMarkup: buildArtifactActionsKeyboard(reports),
@@ -4065,23 +4126,12 @@ export async function registerCommands(bot) {
         { command: "unlock", description: "Release session write lock" },
         { command: "locks", description: "List session write locks" },
         { command: "restart", description: "Admin: restart connector" },
-        { command: "update", description: "Admin: update connector" },
+        { command: "update", description: "Admin: update connector or agents" },
         { command: "handback", description: "Hand session back to CLI" },
         { command: "attach", description: "Bind a session to this topic" },
         { command: "switch", description: "Switch to a thread by ID" },
     ]);
 }
-function renderArtifactReports(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>.";
-    const plain = ["Recent artifacts:", ...lines, "", usage].join("\n");
-    const html = ["<b>Recent artifacts:</b>", ...lines.map(escapeHTML), "", escapeHTML(usage)].join("\n");
-    return { html, plain };
-}
 function renderVersionCheckPlain(check) {
     const icon = versionStatusIcon(check);
     const label = check.label === "NordRelay" ? "NordRelay" : `${check.label} version`;
@@ -4127,73 +4177,6 @@ function formatVersionCheckDetailHTML(check) {
 function versionStatusIcon(check) {
     return check.status === "current" ? "✅" : "⚠️";
 }
-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 === "updates") {
-            target = "update";
-            continue;
-        }
-        if (normalized === "all") {
-            target = "all";
-            continue;
-        }
-        const parsedLines = Number.parseInt(token, 10);
-        if (!Number.isNaN(parsedLines)) {
-            lines = parsedLines;
-        }
-    }
-    return { target, lines };
-}
-function renderLogTailPlain(title, tail) {
-    return [
-        `${title} log tail`,
-        `File: ${tail.filePath}`,
-        `Updated: ${tail.updatedAt ? formatLogDate(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 ? formatLogDate(tail.updatedAt) : "-")}</code>`,
-        `<b>Lines:</b> <code>${tail.lineCount}/${tail.requestedLines}</code>`,
-        "",
-        body,
-    ].join("\n");
-}
-function formatLogDate(date) {
-    return [
-        `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`,
-        `${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())}`,
-    ].join(" ");
-}
-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 renderAuditEvents(events) {
     if (events.length === 0) {
         return {
@@ -4233,29 +4216,6 @@ function renderSessionLocks(locks) {
         html: ["<b>Session locks:</b>", ...lines.map((line) => escapeHTML(line))].join("\n"),
     };
 }
-function renderQueuedPromptDetail(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 formatLockOwner(lock) {
     if (!lock) {
         return "nobody";