@promptbook/cli 0.113.0-8 → 0.114.0-0

package/apps/agents-server/src/app/admin/task-manager/TaskManagerTaskLogActions.tsx

@@ -0,0 +1,150 @@
+'use client';
+
+import { ClipboardCopy, FileDown } from 'lucide-react';
+import { useEffect, useRef, useState } from 'react';
+import type { AdminChatTaskRecord } from '@/src/utils/chatTasksAdmin';
+import { downloadBlob } from '@/src/utils/download/browserFileDownload';
+
+/**
+ * Duration (ms) of the transient feedback shown next to the log action buttons.
+ *
+ * @private constant of `<TaskManagerTaskLogActions/>`
+ */
+const TASK_LOG_ACTION_FEEDBACK_DURATION_MS = 2500;
+
+/**
+ * Props for the post-mortem log copy/download actions of one task row.
+ *
+ * @private function of TaskManagerTaskRow
+ */
+type TaskManagerTaskLogActionsProps = {
+    task: AdminChatTaskRecord;
+};
+
+/**
+ * Builds the downloadable post-mortem log text of one background task.
+ *
+ * @private function of TaskManagerTaskRow
+ */
+export function createTaskPostMortemLogText(task: AdminChatTaskRecord): string {
+    const logLines: Array<string> = [
+        `Task: ${task.id}`,
+        `Kind: ${task.kind}`,
+        `Status: ${task.status}`,
+        `Created: ${task.createdAt}`,
+        `Queued: ${task.queuedAt}`,
+        `Started: ${task.startedAt || '-'}`,
+        `Finished: ${task.finishedAt || '-'}`,
+        `Attempts: ${task.attemptCount}`,
+        `Retries: ${task.retryCount}`,
+        `Worker: ${task.workerId || '-'}`,
+        `Queue: ${task.queueName || '-'}`,
+    ];
+
+    if (task.lastErrorSummary) {
+        logLines.push('', 'Last error summary:', task.lastErrorSummary);
+    }
+
+    if (task.lastErrorDetails) {
+        logLines.push('', 'Last error details:', task.lastErrorDetails);
+    }
+
+    return logLines.join('\n') + '\n';
+}
+
+/**
+ * Resolves a filesystem-safe download filename for one task log.
+ *
+ * @private function of TaskManagerTaskRow
+ */
+function createTaskLogDownloadFilename(task: AdminChatTaskRecord): string {
+    const sanitizedTaskId = task.id.replace(/[^a-zA-Z0-9_-]+/g, '-');
+    return `task-${sanitizedTaskId}-log.txt`;
+}
+
+/**
+ * Copy and download buttons for the post-mortem log of one background task.
+ *
+ * @private function of TaskManagerTaskRow
+ */
+export function TaskManagerTaskLogActions({ task }: TaskManagerTaskLogActionsProps) {
+    const [actionFeedback, setActionFeedback] = useState<string | null>(null);
+    const [actionErrorMessage, setActionErrorMessage] = useState<string | null>(null);
+    const feedbackTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+    useEffect(() => {
+        return () => {
+            if (feedbackTimeoutRef.current !== null) {
+                clearTimeout(feedbackTimeoutRef.current);
+                feedbackTimeoutRef.current = null;
+            }
+        };
+    }, []);
+
+    function showActionFeedback(feedbackMessage: string): void {
+        if (feedbackTimeoutRef.current !== null) {
+            clearTimeout(feedbackTimeoutRef.current);
+        }
+        setActionFeedback(feedbackMessage);
+        setActionErrorMessage(null);
+        feedbackTimeoutRef.current = setTimeout(() => {
+            setActionFeedback(null);
+            feedbackTimeoutRef.current = null;
+        }, TASK_LOG_ACTION_FEEDBACK_DURATION_MS);
+    }
+
+    async function handleCopyLog(): Promise<void> {
+        try {
+            if (!navigator.clipboard?.writeText) {
+                throw new Error('The browser clipboard API is unavailable in this context.');
+            }
+            await navigator.clipboard.writeText(createTaskPostMortemLogText(task));
+            showActionFeedback('Copied!');
+        } catch (error) {
+            setActionErrorMessage(error instanceof Error ? error.message : 'Failed to copy the task log.');
+        }
+    }
+
+    function handleDownloadLog(): void {
+        try {
+            const logBlob = new Blob([createTaskPostMortemLogText(task)], { type: 'text/plain;charset=utf-8' });
+            downloadBlob(logBlob, createTaskLogDownloadFilename(task));
+            showActionFeedback('Saved!');
+        } catch (error) {
+            setActionErrorMessage(error instanceof Error ? error.message : 'Failed to download the task log.');
+        }
+    }
+
+    return (
+        <div className="flex flex-wrap items-center gap-2">
+            <button
+                type="button"
+                onClick={() => void handleCopyLog()}
+                className="inline-flex items-center gap-1 rounded-md border border-gray-200 bg-white px-2 py-1 text-[10px] font-semibold text-gray-600 hover:bg-gray-50"
+                title="Copy the post-mortem log of this task"
+            >
+                <ClipboardCopy className="h-3 w-3" />
+                Copy log
+            </button>
+            <button
+                type="button"
+                onClick={handleDownloadLog}
+                className="inline-flex items-center gap-1 rounded-md border border-gray-200 bg-white px-2 py-1 text-[10px] font-semibold text-gray-600 hover:bg-gray-50"
+                title="Download the post-mortem log of this task"
+            >
+                <FileDown className="h-3 w-3" />
+                Download log
+            </button>
+            {actionFeedback && (
+                <span className="text-[10px] text-emerald-600" role="status" aria-live="polite">
+                    {actionFeedback}
+                </span>
+            )}
+            {actionErrorMessage && (
+                <span className="text-[10px] text-rose-700" role="alert">
+                    {actionErrorMessage}
+                </span>
+            )}
+        </div>
+    );
+}

package/apps/agents-server/src/app/admin/task-manager/TaskManagerTaskRow.tsx

@@ -1,6 +1,27 @@
+'use client';
+
+import { useState } from 'react';
+import Link from 'next/link';
+import { SquareTerminal } from 'lucide-react';
+import { buildAdminChatTaskDetailHref } from '@/src/utils/adminChatTaskLinks';
 import type { AdminChatTaskRecord } from '@/src/utils/chatTasksAdmin';
 import type { ServerLanguageCode } from '@/src/languages/ServerLanguageRegistry';
-import { formatServerLanguageHumanReadableDate } from '@/src/utils/localization/formatServerLanguageHumanReadableDate';
+import { TaskManagerTaskLogActions } from './TaskManagerTaskLogActions';
+import { TaskManagerTaskTargetLink } from './TaskManagerTaskTargetLink';
+import { TaskManagerTaskTerminalDialog } from './TaskManagerTaskTerminalDialog';
+import {
+    buildTaskRunReportRows,
+    formatTaskDateTime,
+    formatTaskDuration,
+    formatTaskKind,
+    getTaskQueueAgeMs,
+    getTaskRuntimeDurationMs,
+    getTaskTotalDurationMs,
+    isTaskStuck,
+    TaskInfoBlock,
+    TaskStatusBadge,
+    truncateTaskText,
+} from './taskManagerTaskPresentation';
 import type { useTaskManagerState } from './useTaskManagerState';
 
 /**
@@ -11,40 +32,15 @@ import type { useTaskManagerState } from './useTaskManagerState';
 type TaskManagerTaskRowProps = {
     busyAction: ReturnType<typeof useTaskManagerState>['busyAction'];
     busyTaskId: ReturnType<typeof useTaskManagerState>['busyTaskId'];
+    isSuperAdmin: boolean;
     language: ServerLanguageCode;
     onRunTaskAction: ReturnType<typeof useTaskManagerState>['runTaskAction'];
     stuckThresholdMinutes: ReturnType<typeof useTaskManagerState>['stuckThresholdMinutes'];
     task: AdminChatTaskRecord;
-};
-
-/**
- * Props for the compact status badge.
- *
- * @private function of TaskManagerTaskRow
- */
-type TaskStatusBadgeProps = {
-    isStuck: boolean;
-    task: AdminChatTaskRecord;
-};
-
-/**
- * One labeled info row shown in a task detail block.
- *
- * @private function of TaskManagerTaskRow
- */
-type TaskInfoRow = {
-    label: string;
-    secondary?: string | null;
-    value: string;
-};
-
-/**
- * Props for the compact task info block.
- *
- * @private function of TaskManagerTaskRow
- */
-type TaskInfoBlockProps = {
-    rows: ReadonlyArray<TaskInfoRow>;
+    /**
+     * Whether to render the originating-server cell (VPS-wide view only).
+     */
+    showServerColumn?: boolean;
 };
 
 /**
@@ -54,197 +50,10 @@ type TaskInfoBlockProps = {
  */
 type TaskManagerTaskActionsProps = Pick<TaskManagerTaskRowProps, 'busyAction' | 'onRunTaskAction' | 'task'> & {
     isBusy: boolean;
+    isSuperAdmin: boolean;
+    onOpenTerminal: () => void;
 };
 
-/**
- * Badge color classes keyed by display status.
- *
- * @private function of TaskManagerTaskRow
- */
-const TASK_STATUS_CLASS_MAP: Record<string, string> = {
-    RUNNING: 'border-blue-200 bg-blue-50 text-blue-700',
-    QUEUED: 'border-slate-200 bg-slate-50 text-slate-700',
-    PAUSED: 'border-orange-200 bg-orange-50 text-orange-700',
-    RETRYING: 'border-amber-200 bg-amber-50 text-amber-700',
-    FAILED: 'border-rose-200 bg-rose-50 text-rose-700',
-    COMPLETED: 'border-emerald-200 bg-emerald-50 text-emerald-700',
-    CANCELLED: 'border-gray-200 bg-gray-100 text-gray-700',
-    STUCK: 'border-orange-300 bg-orange-50 text-orange-800',
-};
-
-/**
- * Renders a compact vertical info block inside the table.
- *
- * @private function of TaskManagerTaskRow
- */
-function TaskInfoBlock({ rows }: TaskInfoBlockProps) {
-    return rows.map((row) => (
-        <div key={`${row.label}-${row.value}`} className="mb-2 last:mb-0">
-            <div className="text-[10px] font-semibold uppercase tracking-wide text-gray-400">{row.label}</div>
-            <div className="break-all text-[11px] text-gray-800">{row.value}</div>
-            {row.secondary ? <div className="break-all text-[11px] text-gray-500">{row.secondary}</div> : null}
-        </div>
-    ));
-}
-
-/**
- * Resolves the effective badge label for a task.
- *
- * @private function of TaskManagerTaskRow
- */
-function resolveTaskStatusLabel(task: AdminChatTaskRecord): string {
-    if (task.status === 'QUEUED' && task.pausedAt) {
-        return 'PAUSED';
-    }
-
-    if (task.status === 'QUEUED' && task.retryCount > 0) {
-        return 'RETRYING';
-    }
-
-    return task.status;
-}
-
-/**
- * Compact badge rendering the effective task status.
- *
- * @private function of TaskManagerTaskRow
- */
-function TaskStatusBadge({ isStuck, task }: TaskStatusBadgeProps) {
-    const label = resolveTaskStatusLabel(task);
-    const tone = isStuck ? TASK_STATUS_CLASS_MAP.STUCK : TASK_STATUS_CLASS_MAP[label] || TASK_STATUS_CLASS_MAP.QUEUED;
-
-    return <span className={`rounded-full border px-2 py-0.5 text-[11px] font-semibold ${tone}`}>{label}</span>;
-}
-
-/**
- * Formats a durable task kind for display.
- *
- * @private function of TaskManagerTaskRow
- */
-function formatTaskKind(kind: AdminChatTaskRecord['kind']): string {
-    if (kind === 'CHAT_COMPLETION') {
-        return 'Chat completion';
-    }
-
-    if (kind === 'CHAT_TIMEOUT') {
-        return 'Chat timeout';
-    }
-
-    if (kind === 'VPS_SELF_UPDATE') {
-        return 'Self-update';
-    }
-
-    if (kind === 'BROWSER_PREVIEW') {
-        return 'Browser preview';
-    }
-
-    return kind;
-}
-
-/**
- * Formats one timestamp for compact table display.
- *
- * @private function of TaskManagerTaskRow
- */
-function formatDateTime(value: string | null, language: ServerLanguageCode): string {
-    return formatServerLanguageHumanReadableDate(value, language, { fallbackLabel: '-' });
-}
-
-/**
- * Formats a duration in milliseconds.
- *
- * @private function of TaskManagerTaskRow
- */
-function formatDuration(durationMs: number | null): string {
-    if (durationMs === null || !Number.isFinite(durationMs) || durationMs < 0) {
-        return '-';
-    }
-
-    const totalSeconds = Math.floor(durationMs / 1000);
-    const days = Math.floor(totalSeconds / 86_400);
-    const hours = Math.floor((totalSeconds % 86_400) / 3_600);
-    const minutes = Math.floor((totalSeconds % 3_600) / 60);
-    const seconds = totalSeconds % 60;
-    const parts: Array<string> = [];
-
-    if (days > 0) {
-        parts.push(`${days}d`);
-    }
-    if (hours > 0) {
-        parts.push(`${hours}h`);
-    }
-    if (minutes > 0) {
-        parts.push(`${minutes}m`);
-    }
-    if (seconds > 0 || parts.length === 0) {
-        parts.push(`${seconds}s`);
-    }
-
-    return parts.slice(0, 2).join(' ');
-}
-
-/**
- * Computes the current queue age for one task.
- *
- * @private function of TaskManagerTaskRow
- */
-function getQueueAgeMs(task: AdminChatTaskRecord): number | null {
-    const queuedAtMs = Date.parse(task.queuedAt);
-    return Number.isNaN(queuedAtMs) ? null : Date.now() - queuedAtMs;
-}
-
-/**
- * Computes runtime duration for running tasks.
- *
- * @private function of TaskManagerTaskRow
- */
-function getRuntimeDurationMs(task: AdminChatTaskRecord): number | null {
-    if (task.status !== 'RUNNING' || !task.startedAt) {
-        return null;
-    }
-
-    const startedAtMs = Date.parse(task.startedAt);
-    return Number.isNaN(startedAtMs) ? null : Date.now() - startedAtMs;
-}
-
-/**
- * Computes total duration for finished tasks.
- *
- * @private function of TaskManagerTaskRow
- */
-function getTotalDurationMs(task: AdminChatTaskRecord): number | null {
-    if (!task.startedAt || !task.finishedAt) {
-        return null;
-    }
-
-    const startedAtMs = Date.parse(task.startedAt);
-    const finishedAtMs = Date.parse(task.finishedAt);
-    if (Number.isNaN(startedAtMs) || Number.isNaN(finishedAtMs)) {
-        return null;
-    }
-
-    return Math.max(0, finishedAtMs - startedAtMs);
-}
-
-/**
- * Detects tasks running longer than the selected threshold.
- *
- * @private function of TaskManagerTaskRow
- */
-function isTaskStuck(task: AdminChatTaskRecord, thresholdMinutes: number): boolean {
-    const runtimeMs = getRuntimeDurationMs(task);
-    return runtimeMs !== null && runtimeMs >= thresholdMinutes * 60_000;
-}
-
-/**
- * Truncates long error text for compact table rendering.
- *
- * @private function of TaskManagerTaskRow
- */
-function truncateText(value: string, limit: number): string {
-    return value.length > limit ? `${value.slice(0, limit - 1)}…` : value;
-}
-
 /**
  * Resolves the row highlight tone for one task.
  *
@@ -267,13 +76,32 @@ function resolveTaskRowClassName(task: AdminChatTaskRecord, isStuck: boolean): s
  *
  * @private function of TaskManagerTaskRow
  */
-function TaskManagerTaskActions({ busyAction, isBusy, onRunTaskAction, task }: TaskManagerTaskActionsProps) {
+function TaskManagerTaskActions({
+    busyAction,
+    isBusy,
+    isSuperAdmin,
+    onOpenTerminal,
+    onRunTaskAction,
+    task,
+}: TaskManagerTaskActionsProps) {
     const isDurableChatTask = task.kind === 'CHAT_COMPLETION' || task.kind === 'CHAT_TIMEOUT';
     const isCancelable = isDurableChatTask && (task.status === 'QUEUED' || task.status === 'RUNNING');
     const isRetryable = isDurableChatTask && task.status === 'FAILED';
 
     return (
-        <div className="flex justify-end gap-2">
+        <div className="flex flex-wrap justify-end gap-2">
+            {isSuperAdmin ? (
+                <button
+                    type="button"
+                    onClick={onOpenTerminal}
+                    className="inline-flex items-center gap-1 rounded-md border border-slate-300 bg-slate-900 px-3 py-1.5 font-semibold text-white hover:bg-slate-800"
+                    title="Open the read-only live CLI terminal of this task"
+                >
+                    <SquareTerminal className="h-3.5 w-3.5" />
+                    Terminal
+                </button>
+            ) : null}
+
             {isCancelable ? (
                 <button
                     type="button"
@@ -296,7 +124,7 @@ function TaskManagerTaskActions({ busyAction, isBusy, onRunTaskAction, task }: T
                 </button>
             ) : null}
 
-            {!isCancelable && !isRetryable ? (
+            {!isCancelable && !isRetryable && !isSuperAdmin ? (
                 <span className="rounded-md border border-gray-200 bg-gray-50 px-3 py-1.5 font-medium text-gray-500">
                     -
                 </span>
@@ -313,18 +141,35 @@ function TaskManagerTaskActions({ busyAction, isBusy, onRunTaskAction, task }: T
 export function TaskManagerTaskRow({
     busyAction,
     busyTaskId,
+    isSuperAdmin,
     language,
     onRunTaskAction,
     stuckThresholdMinutes,
     task,
+    showServerColumn = false,
 }: TaskManagerTaskRowProps) {
+    const [isTerminalDialogOpen, setIsTerminalDialogOpen] = useState(false);
     const isStuck = isTaskStuck(task, stuckThresholdMinutes);
     const isBusy = busyTaskId === task.id;
 
     return (
         <tr className={resolveTaskRowClassName(task, isStuck)}>
+            {showServerColumn ? (
+                <td className="px-4 py-3 align-top">
+                    <div className="font-medium text-gray-800">{task.serverName || 'VPS'}</div>
+                    {task.serverDomain ? (
+                        <div className="mt-1 font-mono text-[10px] text-gray-500">{task.serverDomain}</div>
+                    ) : null}
+                </td>
+            ) : null}
             <td className="px-4 py-3 align-top">
-                <div className="font-mono text-[11px] font-semibold text-gray-900">{task.id}</div>
+                <Link
+                    href={buildAdminChatTaskDetailHref(task.id, task.serverDomain)}
+                    className="font-mono text-[11px] font-semibold text-blue-700 underline-offset-2 hover:underline"
+                    title="Open the task detail page"
+                >
+                    {task.id}
+                </Link>
                 <div className="mt-2 flex flex-wrap gap-2">
                     <TaskStatusBadge task={task} isStuck={isStuck} />
                     <span className="rounded-full border border-gray-200 bg-gray-50 px-2 py-0.5 font-medium text-gray-600">
@@ -342,26 +187,37 @@ export function TaskManagerTaskRow({
                     {task.recurrenceIntervalMs ? (
                         <div>
                             Recurrence:{' '}
-                            <span className="text-gray-700">Every {formatDuration(task.recurrenceIntervalMs)}</span>
+                            <span className="text-gray-700">Every {formatTaskDuration(task.recurrenceIntervalMs)}</span>
                         </div>
                     ) : null}
                     {task.cancelRequestedAt ? (
                         <div className="font-medium text-orange-700">Cancellation requested</div>
                     ) : null}
                     {task.pausedAt ? (
-                        <div className="font-medium text-orange-700">Paused {formatDateTime(task.pausedAt, language)}</div>
+                        <div className="font-medium text-orange-700">
+                            Paused {formatTaskDateTime(task.pausedAt, language)}
+                        </div>
                     ) : null}
                 </div>
             </td>
 
             <td className="px-4 py-3 align-top">
+                <div className="mb-2 last:mb-0">
+                    <div className="text-[10px] font-semibold uppercase tracking-wide text-gray-400">User</div>
+                    {task.userId > 0 ? (
+                        <Link
+                            href={`/admin/users/${encodeURIComponent(task.username || String(task.userId))}`}
+                            className="break-all text-[11px] text-blue-700 hover:underline"
+                        >
+                            #{task.userId}
+                        </Link>
+                    ) : (
+                        <span className="break-all text-[11px] text-gray-800">#{task.userId}</span>
+                    )}
+                    <div className="break-all text-[11px] text-gray-500">{task.username || '-'}</div>
+                </div>
                 <TaskInfoBlock
                     rows={[
-                        {
-                            label: 'User',
-                            value: `#${task.userId}`,
-                            secondary: task.username || '-',
-                        },
                         {
                             label: 'Agent',
                             value: task.agentName || task.agentPermanentId,
@@ -370,15 +226,18 @@ export function TaskManagerTaskRow({
                         { label: 'Chat', value: task.chatId },
                     ]}
                 />
+                <div className="mt-2">
+                    <TaskManagerTaskTargetLink task={task} />
+                </div>
             </td>
 
             <td className="px-4 py-3 align-top">
                 <TaskInfoBlock
                     rows={[
-                        { label: 'Created', value: formatDateTime(task.createdAt, language) },
-                        { label: 'Started', value: formatDateTime(task.startedAt, language) },
-                        { label: 'Updated', value: formatDateTime(task.updatedAt, language) },
-                        { label: 'Finished', value: formatDateTime(task.finishedAt, language) },
+                        { label: 'Created', value: formatTaskDateTime(task.createdAt, language) },
+                        { label: 'Started', value: formatTaskDateTime(task.startedAt, language) },
+                        { label: 'Updated', value: formatTaskDateTime(task.updatedAt, language) },
+                        { label: 'Finished', value: formatTaskDateTime(task.finishedAt, language) },
                     ]}
                 />
             </td>
@@ -386,10 +245,10 @@ export function TaskManagerTaskRow({
             <td className="px-4 py-3 align-top">
                 <TaskInfoBlock
                     rows={[
-                        { label: 'Queue age', value: formatDuration(getQueueAgeMs(task)) },
-                        { label: 'Runtime', value: formatDuration(getRuntimeDurationMs(task)) },
-                        { label: 'Total', value: formatDuration(getTotalDurationMs(task)) },
-                        { label: 'Heartbeat', value: formatDateTime(task.lastHeartbeatAt, language) },
+                        { label: 'Queue age', value: formatTaskDuration(getTaskQueueAgeMs(task)) },
+                        { label: 'Runtime', value: formatTaskDuration(getTaskRuntimeDurationMs(task)) },
+                        { label: 'Total', value: formatTaskDuration(getTaskTotalDurationMs(task)) },
+                        { label: 'Heartbeat', value: formatTaskDateTime(task.lastHeartbeatAt, language) },
                     ]}
                 />
             </td>
@@ -399,28 +258,32 @@ export function TaskManagerTaskRow({
                     rows={[
                         { label: 'Queue', value: task.queueName || '-' },
                         { label: 'Worker', value: task.workerId || '-' },
-                        { label: 'Lease expires', value: formatDateTime(task.leaseExpiresAt, language) },
-                        { label: 'Paused at', value: formatDateTime(task.pausedAt, language) },
+                        { label: 'Lease expires', value: formatTaskDateTime(task.leaseExpiresAt, language) },
+                        { label: 'Paused at', value: formatTaskDateTime(task.pausedAt, language) },
+                        ...buildTaskRunReportRows(task.runReport),
                     ]}
                 />
             </td>
 
             <td className="max-w-xs px-4 py-3 align-top text-[11px] leading-relaxed text-gray-600">
-                {task.lastErrorSummary || task.lastErrorDetails ? (
-                    <div className="space-y-2">
-                        {task.lastErrorSummary ? <div>{truncateText(task.lastErrorSummary, 220)}</div> : null}
-                        {task.lastErrorDetails ? (
-                            <details className="rounded-md border border-gray-200 bg-gray-50 p-2">
-                                <summary className="cursor-pointer font-medium text-gray-700">Show details</summary>
-                                <pre className="mt-2 overflow-x-auto whitespace-pre-wrap break-words text-[10px] leading-relaxed text-gray-600">
-                                    {task.lastErrorDetails}
-                                </pre>
-                            </details>
-                        ) : null}
-                    </div>
-                ) : (
-                    '-'
-                )}
+                <div className="space-y-2">
+                    {task.lastErrorSummary || task.lastErrorDetails ? (
+                        <>
+                            {task.lastErrorSummary ? <div>{truncateTaskText(task.lastErrorSummary, 220)}</div> : null}
+                            {task.lastErrorDetails ? (
+                                <details className="rounded-md border border-gray-200 bg-gray-50 p-2">
+                                    <summary className="cursor-pointer font-medium text-gray-700">Show details</summary>
+                                    <pre className="mt-2 overflow-x-auto whitespace-pre-wrap break-words text-[10px] leading-relaxed text-gray-600">
+                                        {task.lastErrorDetails}
+                                    </pre>
+                                </details>
+                            ) : null}
+                        </>
+                    ) : (
+                        '-'
+                    )}
+                    <TaskManagerTaskLogActions task={task} />
+                </div>
             </td>
 
             <td className="px-4 py-3 align-top">
@@ -428,8 +291,13 @@ export function TaskManagerTaskRow({
                     task={task}
                     busyAction={busyAction}
                     isBusy={isBusy}
+                    isSuperAdmin={isSuperAdmin}
+                    onOpenTerminal={() => setIsTerminalDialogOpen(true)}
                     onRunTaskAction={onRunTaskAction}
                 />
+                {isTerminalDialogOpen ? (
+                    <TaskManagerTaskTerminalDialog task={task} onClose={() => setIsTerminalDialogOpen(false)} />
+                ) : null}
             </td>
         </tr>
     );