agent-nuvira 2.7.0 → 2.7.2

package/dist/web-dashboard/src/components/TaskConsole.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * TaskConsole — a reusable "run a CLI command" console for the dashboard.
+ *
+ * Renders preset buttons + a custom-command input, starts the command through
+ * the P1 task runner (the REAL CLI as an isolated child process), and streams
+ * the live output via SSE with cancel. Used by the Evals tab and the Gateway
+ * ops tab — one console, many surfaces.
+ *
+ * Running commands is a write action: the console is gated behind the admin
+ * session + routing.operate (admin or operator).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = TaskConsole;
+const react_1 = require("react");
+const api_1 = require("../api");
+const STATUS_LABEL = {
+    running: '⏳ running',
+    done: '✅ done',
+    failed: '❌ failed',
+    cancelled: '⏹ cancelled',
+    timeout: '⏰ timed out',
+    error: '💥 error',
+};
+function TaskConsole({ presets, customPlaceholder, timeoutMs = 300_000, hint }) {
+    const [auth, setAuth] = (0, react_1.useState)(null);
+    const [running, setRunning] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)('');
+    const [custom, setCustom] = (0, react_1.useState)('');
+    const [active, setActive] = (0, react_1.useState)(null);
+    const [logs, setLogs] = (0, react_1.useState)([]);
+    const logEndRef = (0, react_1.useRef)(null);
+    const subRef = (0, react_1.useRef)(null);
+    (0, react_1.useEffect)(() => {
+        void api_1.dashboardAPI.fetchAdminAuthStatus().then((s) => {
+            setAuth(s ? { authenticated: s.authenticated, role: s.role } : { authenticated: false, role: null });
+        });
+    }, []);
+    (0, react_1.useEffect)(() => {
+        try {
+            logEndRef.current?.scrollIntoView?.({ block: 'end' });
+        }
+        catch {
+            /* jsdom / non-DOM environments */
+        }
+    }, [logs]);
+    (0, react_1.useEffect)(() => {
+        return () => {
+            subRef.current?.();
+        };
+    }, []);
+    const canRun = auth?.authenticated === true && (auth.role === 'admin' || auth.role === 'operator');
+    const start = (0, react_1.useCallback)(async (args, presetTimeoutMs) => {
+        if (running)
+            return;
+        setRunning(true);
+        setError('');
+        setLogs([]);
+        const r = await api_1.dashboardAPI.startTask(args, presetTimeoutMs ?? timeoutMs);
+        if (!r.ok || !r.task) {
+            setError(r.error || 'Could not start the command.');
+            setRunning(false);
+            return;
+        }
+        const task = r.task;
+        setActive(task);
+        const init = await api_1.dashboardAPI.getTask(task.id);
+        if (init?.task) {
+            setLogs(init.task.logs.map((l) => ({ stream: l.stream, text: l.text })));
+        }
+        subRef.current?.();
+        subRef.current = api_1.dashboardAPI.subscribeTask(task.id, {
+            onLog: (line) => setLogs((l) => [...l, { stream: line.stream, text: line.text }]),
+            onStatus: (status) => {
+                setActive((t) => (t ? { ...t, status } : t));
+                if (status !== 'running')
+                    setRunning(false);
+            },
+        });
+    }, [running, timeoutMs]);
+    const cancel = (0, react_1.useCallback)(async () => {
+        if (!active)
+            return;
+        await api_1.dashboardAPI.cancelTask(active.id);
+    }, [active]);
+    return (<div className="ops-console">
+      {!auth?.authenticated ? (<div className="admin-login-hint">Log in (admin or operator) to run commands.</div>) : !canRun ? (<div className="admin-login-hint">Your role can view but not run commands (requires admin or operator).</div>) : (<>
+          <div className="ops-presets">
+            {presets.map((p) => (<button key={p.label} className="admin-refresh-btn" type="button" onClick={() => void start(p.args, p.timeoutMs)} disabled={running}>
+                {p.label}
+              </button>))}
+          </div>
+          <div className="ops-custom-row">
+            <input type="text" value={custom} onChange={(e) => setCustom(e.target.value)} placeholder={customPlaceholder} disabled={running} maxLength={160}/>
+            <button className="admin-refresh-btn" type="button" onClick={() => void start(custom.trim().split(/\s+/))} disabled={running || !custom.trim()}>
+              Run
+            </button>
+          </div>
+          {hint ? <p className="admin-hint">{hint}</p> : null}
+        </>)}
+
+      {error ? <div className="admin-row-msg admin-row-msg-err">{error}</div> : null}
+
+      {active ? (<div className="ops-console-box">
+          <div className="ops-console-head">
+            <span>
+              {active.command} · <span className={active.status === 'running' ? 'task-status-running' : ''}>{STATUS_LABEL[active.status]}</span>
+            </span>
+            {active.status === 'running' ? (<button className="admin-refresh-btn" type="button" onClick={() => void cancel()}>
+                ⏹ Cancel
+              </button>) : null}
+          </div>
+          <pre className="ops-console" role="log">
+            {logs.length > 0 ? logs.map((l, i) => <div key={i}>{l.text}</div>) : <div className="admin-hint">Waiting for output…</div>}
+            <div ref={logEndRef}/>
+          </pre>
+        </div>) : null}
+    </div>);
+}

package/dist/web-dashboard/src/components/TaskConsole.test.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * P2/P3 — TaskConsole tests (the shared CLI-run console).
+ *
+ * Used by the Evals tab and the Gateway ops tab: preset buttons + a custom
+ * command input start the REAL CLI through the mocked task API, and the live
+ * SSE console (subscribeTask) streams output with cancel. The console is the
+ * shared surface, so its mechanics are tested here once.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const react_1 = require("@testing-library/react");
+const TaskConsole_1 = __importDefault(require("./TaskConsole"));
+const api_1 = require("../api");
+const PRESETS = [
+    { label: '🌐 Gateway status', args: ['gateway', 'status'] },
+    { label: '▶️ Start gateway (foreground)', args: ['gateway', 'start', '--no-events'] },
+];
+const TASK = {
+    id: 'task-1',
+    command: 'gateway status',
+    args: ['gateway', 'status'],
+    cwd: '/tmp',
+    status: 'running',
+    exitCode: null,
+    startedAt: Date.now(),
+    finishedAt: null,
+    durationMs: null,
+    timeoutMs: 300000,
+    logs: [],
+};
+function mockAuthed(authenticated = true, role = 'admin') {
+    vitest_1.vi.spyOn(api_1.dashboardAPI, 'fetchAdminAuthStatus').mockResolvedValue({
+        configured: true,
+        authenticated,
+        user: authenticated ? 'admin' : null,
+        role: authenticated ? role : null,
+    });
+}
+function mockRunApi() {
+    vitest_1.vi.spyOn(api_1.dashboardAPI, 'startTask').mockResolvedValue({ ok: true, task: TASK });
+    vitest_1.vi.spyOn(api_1.dashboardAPI, 'getTask').mockResolvedValue({ status: 200, task: TASK });
+    vitest_1.vi.spyOn(api_1.dashboardAPI, 'subscribeTask').mockReturnValue(() => { });
+}
+(0, vitest_1.afterEach)(() => {
+    (0, react_1.cleanup)();
+    vitest_1.vi.restoreAllMocks();
+    (0, api_1.setAdminToken)(null);
+});
+(0, vitest_1.describe)('TaskConsole', () => {
+    (0, vitest_1.it)('gates running behind admin/operator roles', async () => {
+        mockAuthed(false);
+        (0, react_1.render)(<TaskConsole_1.default presets={PRESETS} customPlaceholder="run something"/>);
+        await (0, react_1.waitFor)(() => (0, vitest_1.expect)(react_1.screen.getByText(/Log in \(admin or operator\)/)).toBeTruthy());
+        mockAuthed(true, 'viewer');
+        (0, react_1.cleanup)();
+        (0, react_1.render)(<TaskConsole_1.default presets={PRESETS} customPlaceholder="run something"/>);
+        await (0, react_1.waitFor)(() => (0, vitest_1.expect)(react_1.screen.getByText(/view but not run/)).toBeTruthy());
+        (0, vitest_1.expect)(react_1.screen.queryByRole('button', { name: /Gateway status/ })).toBeNull();
+    });
+    (0, vitest_1.it)('a preset button starts its args with the timeout', async () => {
+        mockAuthed();
+        mockRunApi();
+        const start = vitest_1.vi.mocked(api_1.dashboardAPI.startTask);
+        (0, react_1.render)(<TaskConsole_1.default presets={PRESETS} customPlaceholder="run something" timeoutMs={123456}/>);
+        await (0, react_1.waitFor)(() => (0, vitest_1.expect)(react_1.screen.getByRole('button', { name: /Gateway status/ })).toBeTruthy());
+        react_1.fireEvent.click(react_1.screen.getByRole('button', { name: /Gateway status/ }));
+        await (0, react_1.waitFor)(() => (0, vitest_1.expect)(start).toHaveBeenCalledWith(['gateway', 'status'], 123456));
+    });
+    (0, vitest_1.it)('the custom input splits the command line into args', async () => {
+        mockAuthed();
+        mockRunApi();
+        const start = vitest_1.vi.mocked(api_1.dashboardAPI.startTask);
+        (0, react_1.render)(<TaskConsole_1.default presets={PRESETS} customPlaceholder="run something"/>);
+        await (0, react_1.waitFor)(() => (0, vitest_1.expect)(react_1.screen.getByPlaceholderText('run something')).toBeTruthy());
+        const input = react_1.screen.getByPlaceholderText('run something');
+        react_1.fireEvent.change(input, { target: { value: 'admin cron run nightly' } });
+        react_1.fireEvent.click(react_1.screen.getByRole('button', { name: 'Run' }));
+        await (0, react_1.waitFor)(() => (0, vitest_1.expect)(start).toHaveBeenCalledWith(['admin', 'cron', 'run', 'nightly'], 300_000));
+    });
+    (0, vitest_1.it)('streams the live console, offers cancel, and stops on completion', async () => {
+        mockAuthed();
+        mockRunApi();
+        let onLog = null;
+        let onStatus = null;
+        vitest_1.vi.spyOn(api_1.dashboardAPI, 'subscribeTask').mockImplementation((_id, handlers) => {
+            onLog = handlers.onLog;
+            onStatus = handlers.onStatus;
+            return vitest_1.vi.fn();
+        });
+        vitest_1.vi.spyOn(api_1.dashboardAPI, 'getTask').mockResolvedValue({
+            status: 200,
+            task: { ...TASK, logs: [{ stream: 'stdout', text: 'gateway: channels loaded', at: Date.now() }] },
+        });
+        const cancel = vitest_1.vi.spyOn(api_1.dashboardAPI, 'cancelTask').mockResolvedValue({ ok: true });
+        (0, react_1.render)(<TaskConsole_1.default presets={PRESETS} customPlaceholder="run something"/>);
+        await (0, react_1.waitFor)(() => (0, vitest_1.expect)(react_1.screen.getByRole('button', { name: /Gateway status/ })).toBeTruthy());
+        react_1.fireEvent.click(react_1.screen.getByRole('button', { name: /Gateway status/ }));
+        await (0, react_1.waitFor)(() => (0, vitest_1.expect)(react_1.screen.getByText('gateway: channels loaded')).toBeTruthy());
+        // Live line streams in while running.
+        onLog({ stream: 'stdout', text: 'telegram: connected' });
+        await (0, react_1.waitFor)(() => (0, vitest_1.expect)(react_1.screen.getByText('telegram: connected')).toBeTruthy());
+        (0, vitest_1.expect)(react_1.screen.getByRole('button', { name: /Cancel/ })).toBeTruthy();
+        react_1.fireEvent.click(react_1.screen.getByRole('button', { name: /Cancel/ }));
+        await (0, react_1.waitFor)(() => (0, vitest_1.expect)(cancel).toHaveBeenCalledWith('task-1'));
+        // Completion turns the console to done and drops the cancel button.
+        onStatus('done');
+        await (0, react_1.waitFor)(() => (0, vitest_1.expect)(react_1.screen.getByText(/done/)).toBeTruthy());
+        (0, vitest_1.expect)(react_1.screen.queryByRole('button', { name: /Cancel/ })).toBeNull();
+    });
+    (0, vitest_1.it)('surfaces a start failure instead of streaming', async () => {
+        mockAuthed();
+        vitest_1.vi.spyOn(api_1.dashboardAPI, 'startTask').mockResolvedValue({ ok: false, error: 'CLI not found' });
+        (0, react_1.render)(<TaskConsole_1.default presets={PRESETS} customPlaceholder="run something"/>);
+        await (0, react_1.waitFor)(() => (0, vitest_1.expect)(react_1.screen.getByRole('button', { name: /Gateway status/ })).toBeTruthy());
+        react_1.fireEvent.click(react_1.screen.getByRole('button', { name: /Gateway status/ }));
+        await (0, react_1.waitFor)(() => (0, vitest_1.expect)(react_1.screen.getByText(/CLI not found/)).toBeTruthy());
+        (0, vitest_1.expect)(react_1.screen.queryByRole('button', { name: /Cancel/ })).toBeNull();
+    });
+});

package/dist/web-dashboard/src/components/TasksPage.js

@@ -0,0 +1,256 @@
+"use strict";
+/**
+ * TasksPage — P1 command console.
+ *
+ * The dashboard's task runner executes the agent-nuvira CLI as an isolated
+ * child process (`node dist/index.js <args>`), so every command that works in
+ * a terminal works here too — the GUI is literally running the CLI. This page
+ * provides the run form, a live log console (SSE), cancel, and history.
+ *
+ * Running commands is a write action: the page is gated behind the same admin
+ * session as the other action surfaces (Admin, Agent Hub toggles).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = TasksPage;
+const react_1 = require("react");
+const react_router_dom_1 = require("react-router-dom");
+const api_1 = require("../api");
+const STATUS_LABEL = {
+    running: '⏳ running',
+    done: '✅ done',
+    failed: '❌ failed',
+    cancelled: '⏹ cancelled',
+    timeout: '⏰ timed out',
+    error: '💥 error',
+};
+function statusClass(status) {
+    switch (status) {
+        case 'done': return 'task-status-done';
+        case 'running': return 'task-status-running';
+        case 'failed': return 'task-status-failed';
+        case 'cancelled': return 'task-status-cancelled';
+        case 'timeout': return 'task-status-timeout';
+        default: return 'task-status-error';
+    }
+}
+/** Split a command line into argv (whitespace, quote-aware). */
+function splitArgs(line) {
+    const out = [];
+    let cur = '';
+    let quote = null;
+    for (const ch of line.trim()) {
+        if (quote) {
+            if (ch === quote)
+                quote = null;
+            else
+                cur += ch;
+        }
+        else if (ch === '"' || ch === "'") {
+            quote = ch;
+        }
+        else if (/\s/.test(ch)) {
+            if (cur) {
+                out.push(cur);
+                cur = '';
+            }
+        }
+        else {
+            cur += ch;
+        }
+    }
+    if (cur)
+        out.push(cur);
+    return out;
+}
+function fmtDuration(ms) {
+    if (ms === null)
+        return '—';
+    if (ms < 1000)
+        return `${ms}ms`;
+    return `${(ms / 1000).toFixed(1)}s`;
+}
+function fmtAge(at) {
+    const s = Math.max(0, Math.floor((Date.now() - at) / 1000));
+    if (s < 60)
+        return `${s}s ago`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m ago`;
+    return `${Math.floor(m / 60)}h ago`;
+}
+function TasksPage() {
+    const [auth, setAuth] = (0, react_1.useState)(null);
+    const [command, setCommand] = (0, react_1.useState)('');
+    const [timeoutSec, setTimeoutSec] = (0, react_1.useState)(300);
+    const [starting, setStarting] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)('');
+    // The task being displayed in the console (running or a selected history task).
+    const [active, setActive] = (0, react_1.useState)(null);
+    const [history, setHistory] = (0, react_1.useState)([]);
+    const [autoScroll, setAutoScroll] = (0, react_1.useState)(true);
+    const logEndRef = (0, react_1.useRef)(null);
+    const subRef = (0, react_1.useRef)(null);
+    const refreshHistory = (0, react_1.useCallback)(async () => {
+        const r = await api_1.dashboardAPI.listTasks();
+        if (r)
+            setHistory(r.tasks);
+    }, []);
+    (0, react_1.useEffect)(() => {
+        void api_1.dashboardAPI.fetchAdminAuthStatus().then((s) => {
+            setAuth(s
+                ? { configured: s.configured, authenticated: s.authenticated, role: s.role }
+                : { configured: false, authenticated: false, role: null });
+            if (s?.authenticated)
+                void refreshHistory();
+        });
+    }, [refreshHistory]);
+    // Auto-scroll the console to the newest line while running.
+    (0, react_1.useEffect)(() => {
+        if (autoScroll && active?.status === 'running') {
+            try {
+                logEndRef.current?.scrollIntoView?.({ block: 'end' });
+            }
+            catch {
+                /* jsdom / non-DOM scroll environments */
+            }
+        }
+    }, [active?.logs.length, active?.status, autoScroll]);
+    (0, react_1.useEffect)(() => () => subRef.current?.(), []);
+    const openTask = (0, react_1.useCallback)((task, subscribe) => {
+        subRef.current?.();
+        setActive(task);
+        setError('');
+        if (!subscribe)
+            return;
+        const off = api_1.dashboardAPI.subscribeTask(task.id, {
+            onLog: (line) => setActive((prev) => (prev && prev.id === task.id ? { ...prev, logs: [...prev.logs, line] } : prev)),
+            onStatus: (status) => setActive((prev) => (prev && prev.id === task.id ? { ...prev, status } : prev)),
+        });
+        subRef.current = off;
+    }, []);
+    const run = (0, react_1.useCallback)(async () => {
+        const args = splitArgs(command);
+        if (args.length === 0) {
+            setError('Type a command first — e.g. `eval run --task smoke-test` or `gateway status`.');
+            return;
+        }
+        setStarting(true);
+        setError('');
+        const r = await api_1.dashboardAPI.startTask(args, timeoutSec * 1000);
+        setStarting(false);
+        if (!r.ok || !r.task) {
+            setError(r.error || 'Failed to start task.');
+            return;
+        }
+        setCommand('');
+        void refreshHistory();
+        openTask(r.task, true);
+    }, [command, timeoutSec, openTask, refreshHistory]);
+    const cancel = (0, react_1.useCallback)(async (id) => {
+        await api_1.dashboardAPI.cancelTask(id);
+    }, []);
+    const showHistory = (0, react_1.useCallback)(async (id) => {
+        const r = await api_1.dashboardAPI.getTask(id);
+        if (r?.task)
+            openTask(r.task, false);
+    }, [openTask]);
+    const clearConsole = (0, react_1.useCallback)(() => {
+        subRef.current?.();
+        setActive(null);
+    }, []);
+    if (!auth) {
+        return (<div className="panel">
+        <h2 className="panel-title">🚀 Command Console</h2>
+        <div className="loading-state">Loading…</div>
+      </div>);
+    }
+    if (!auth.authenticated) {
+        return (<div className="panel">
+        <h2 className="panel-title">🚀 Command Console</h2>
+        <div className="empty-state">
+          <p>
+            <strong>Log in to run tasks.</strong> The console executes commands on this machine, so it needs an
+            admin session (like the Agent Hub toggles).
+          </p>
+          <p>
+            {auth.configured ? (<react_router_dom_1.Link className="admin-refresh-btn" to="/admin">🔐 Log in</react_router_dom_1.Link>) : (<react_router_dom_1.Link className="admin-refresh-btn" to="/admin">🔐 Create admin account</react_router_dom_1.Link>)}
+          </p>
+        </div>
+      </div>);
+    }
+    return (<div className="panel">
+      <h2 className="panel-title">🚀 Command Console</h2>
+      <p className="admin-subtitle">
+        Run any agent-nuvira command — the same CLI, executed by the dashboard. Messaging, skills, tools, eval,
+        memory, traces and more.
+      </p>
+
+      <form className="task-run-form" onSubmit={(e) => {
+            e.preventDefault();
+            void run();
+        }}>
+        <input className="admin-input task-cmd-input" placeholder="eval run --task smoke-test   ·   gateway status   ·   skill list   ·   memory stats" value={command} onChange={(e) => setCommand(e.target.value)} autoComplete="off" spellCheck={false}/>
+        <select className="admin-input task-timeout-select" title="Task timeout" value={timeoutSec} onChange={(e) => setTimeoutSec(Number(e.target.value))}>
+          <option value={60}>1 min</option>
+          <option value={300}>5 min</option>
+          <option value={600}>10 min</option>
+          <option value={1800}>30 min</option>
+        </select>
+        <button className="admin-refresh-btn" type="submit" disabled={starting || command.trim() === ''}>
+          {starting ? '⏳ Starting…' : '▶ Run'}
+        </button>
+      </form>
+      {error && <div className="admin-error">{error}</div>}
+      <p className="task-hint">
+        Long-running commands stream their output live. Runs are capped at the chosen timeout and can be cancelled.
+      </p>
+
+      {active && (<div className="task-console-wrap">
+          <div className="task-console-header">
+            <code className="task-console-cmd">{active.command}</code>
+            <span className={`task-status ${statusClass(active.status)}`}>{STATUS_LABEL[active.status]}</span>
+            <span className="task-meta">
+              exit {active.exitCode ?? '—'} · {fmtDuration(active.durationMs)}
+            </span>
+            {active.status === 'running' && (<button className="admin-mini-btn task-cancel-btn" onClick={() => void cancel(active.id)}>
+                ⏹ Cancel
+              </button>)}
+            <button className="admin-mini-btn" onClick={clearConsole}>✕ Close</button>
+          </div>
+          <div className="task-console">
+            {active.logs.map((line, i) => (<div key={i} className={`task-line task-line-${line.stream}`}>
+                {line.text}
+              </div>))}
+            {active.logs.length === 0 && active.status === 'running' && (<div className="task-line task-line-system">⏳ waiting for output…</div>)}
+            <div ref={logEndRef}/>
+          </div>
+          <label className="task-autoscroll">
+            <input type="checkbox" checked={autoScroll} onChange={(e) => setAutoScroll(e.target.checked)}/> auto-scroll
+          </label>
+        </div>)}
+
+      <h3 className="task-history-title">History</h3>
+      {history.length === 0 ? (<div className="empty-state">No tasks yet — run your first command above.</div>) : (<div className="admin-table-wrapper">
+          <table className="admin-table task-table">
+            <thead>
+              <tr>
+                <th>Command</th>
+                <th>Status</th>
+                <th>Exit</th>
+                <th>Duration</th>
+                <th>When</th>
+              </tr>
+            </thead>
+            <tbody>
+              {history.map((t) => (<tr key={t.id} className={active?.id === t.id ? 'task-row-active' : ''} onClick={() => void showHistory(t.id)}>
+                  <td><code>{t.command}</code></td>
+                  <td><span className={`task-status ${statusClass(t.status)}`}>{STATUS_LABEL[t.status]}</span></td>
+                  <td>{t.exitCode ?? '—'}</td>
+                  <td>{fmtDuration(t.durationMs)}</td>
+                  <td>{fmtAge(t.startedAt)}</td>
+                </tr>))}
+            </tbody>
+          </table>
+        </div>)}
+    </div>);
+}

package/dist/web-dashboard/src/components/TasksPage.test.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * TasksPage — command console tests (P1).
+ *
+ * - Unauthenticated users see the login gate (running commands is a write
+ *   action, like the Agent Hub toggles).
+ * - Authenticated users get the run form + history table.
+ * - Typing a command and hitting Run calls startTask with the parsed argv and
+ *   subscribes to the task's SSE stream.
+ * - The Run button is disabled while the command is empty / while starting.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const react_1 = require("@testing-library/react");
+const react_router_dom_1 = require("react-router-dom");
+const TasksPage_1 = __importDefault(require("./TasksPage"));
+const api_1 = require("../api");
+const TASK = {
+    id: 't1',
+    command: 'eval run --task smoke',
+    args: ['eval', 'run', '--task', 'smoke'],
+    cwd: '/workspace',
+    status: 'done',
+    exitCode: 0,
+    startedAt: Date.now() - 5000,
+    finishedAt: Date.now(),
+    durationMs: 5000,
+    timeoutMs: 300000,
+    logs: [{ stream: 'stdout', text: 'hello from fixture', at: Date.now() }],
+};
+function mockAuthed() {
+    vitest_1.vi.spyOn(api_1.dashboardAPI, 'fetchAdminAuthStatus').mockResolvedValue({
+        configured: true,
+        authenticated: true,
+        user: 'admin',
+        role: 'admin',
+    });
+    vitest_1.vi.spyOn(api_1.dashboardAPI, 'listTasks').mockResolvedValue({ status: 200, tasks: [TASK] });
+}
+(0, vitest_1.afterEach)(() => {
+    (0, react_1.cleanup)();
+    vitest_1.vi.restoreAllMocks();
+    (0, api_1.setAdminToken)(null);
+});
+function renderPage() {
+    (0, react_1.render)(<react_router_dom_1.MemoryRouter>
+      <TasksPage_1.default />
+    </react_router_dom_1.MemoryRouter>);
+}
+(0, vitest_1.describe)('TasksPage', () => {
+    (0, vitest_1.it)('shows the login gate when unauthenticated', async () => {
+        vitest_1.vi.spyOn(api_1.dashboardAPI, 'fetchAdminAuthStatus').mockResolvedValue({
+            configured: true,
+            authenticated: false,
+            user: null,
+            role: null,
+        });
+        renderPage();
+        await (0, react_1.waitFor)(() => (0, vitest_1.expect)(react_1.screen.getByText(/Log in to run tasks/)).toBeTruthy());
+    });
+    (0, vitest_1.it)('renders the run form and history when authed', async () => {
+        mockAuthed();
+        renderPage();
+        await (0, react_1.waitFor)(() => (0, vitest_1.expect)(react_1.screen.getByPlaceholderText(/eval run --task smoke-test/)).toBeTruthy());
+        // History table row shows the finished task.
+        await (0, react_1.waitFor)(() => (0, vitest_1.expect)(react_1.screen.getByText('eval run --task smoke')).toBeTruthy());
+        (0, vitest_1.expect)(react_1.screen.getByText(/✅ done/)).toBeTruthy();
+    });
+    (0, vitest_1.it)('disables Run while the command is empty', async () => {
+        mockAuthed();
+        renderPage();
+        await (0, react_1.waitFor)(() => (0, vitest_1.expect)(react_1.screen.getByPlaceholderText(/eval run --task smoke-test/)).toBeTruthy());
+        (0, vitest_1.expect)(react_1.screen.getByRole('button', { name: /▶ Run/ }).disabled).toBe(true);
+    });
+    (0, vitest_1.it)('starts a task from the typed command and subscribes to its stream', async () => {
+        mockAuthed();
+        const startMock = vitest_1.vi.spyOn(api_1.dashboardAPI, 'startTask').mockResolvedValue({
+            ok: true,
+            task: { ...TASK, id: 't2', command: 'memory stats', args: ['memory', 'stats'], status: 'running', logs: [] },
+        });
+        const subMock = vitest_1.vi.spyOn(api_1.dashboardAPI, 'subscribeTask').mockReturnValue(() => { });
+        renderPage();
+        const input = await react_1.screen.findByPlaceholderText(/eval run --task smoke-test/);
+        react_1.fireEvent.change(input, { target: { value: 'memory stats' } });
+        react_1.fireEvent.click(react_1.screen.getByRole('button', { name: /▶ Run/ }));
+        await (0, react_1.waitFor)(() => (0, vitest_1.expect)(startMock).toHaveBeenCalledWith(['memory', 'stats'], 300000));
+        await (0, react_1.waitFor)(() => (0, vitest_1.expect)(subMock).toHaveBeenCalledWith('t2', vitest_1.expect.any(Object)));
+        // The console header shows the running command.
+        await (0, react_1.waitFor)(() => (0, vitest_1.expect)(react_1.screen.getByText('memory stats')).toBeTruthy());
+    });
+    (0, vitest_1.it)('shows a friendly error when start fails', async () => {
+        mockAuthed();
+        vitest_1.vi.spyOn(api_1.dashboardAPI, 'startTask').mockResolvedValue({ ok: false, error: 'Missing command args.' });
+        renderPage();
+        const input = await react_1.screen.findByPlaceholderText(/eval run --task smoke-test/);
+        react_1.fireEvent.change(input, { target: { value: 'eval run' } });
+        react_1.fireEvent.click(react_1.screen.getByRole('button', { name: /▶ Run/ }));
+        await (0, react_1.waitFor)(() => (0, vitest_1.expect)(react_1.screen.getByText(/Missing command args/)).toBeTruthy());
+    });
+});