@livedesk/client 0.1.63 → 0.1.65

package/bin/livedesk-client.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, statfsSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn, spawnSync } from 'node:child_process';
@@ -429,6 +429,10 @@ function writeSavedSessionToFile(session) {
     return true;
 }
 
+function clearSavedSession() {
+    rmSync(CLIENT_AUTH_PATH, { force: true });
+}
+
 async function createSupabaseClient() {
     const { createClient } = await import('@supabase/supabase-js');
     return createClient(SUPABASE_URL, SUPABASE_PUBLISHABLE_KEY, {
@@ -466,6 +470,14 @@ function getNestedErrorMessage(error) {
     return messages.join(' ');
 }
 
+function isInvalidRefreshTokenError(error) {
+    const code = getNestedErrorCode(error).toLowerCase();
+    const message = getNestedErrorMessage(error);
+    return code === 'refresh_token_not_found'
+        || code === 'invalid_grant'
+        || /invalid refresh token|refresh token not found/i.test(message);
+}
+
 function isTransientNetworkError(error) {
     const code = getNestedErrorCode(error).toUpperCase();
     if (['ENOTFOUND', 'EAI_AGAIN', 'ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT', 'ENETUNREACH', 'EHOSTUNREACH'].includes(code)) {
@@ -483,8 +495,18 @@ function formatDiscoveryError(error) {
 }
 
 async function refreshSessionIfNeeded(supabase) {
-    const { data: existing } = await supabase.auth.getSession();
-    const session = existing?.session || readSavedSessionFromFile();
+    let existingSession = null;
+    try {
+        const { data: existing } = await supabase.auth.getSession();
+        existingSession = existing?.session || null;
+    } catch (error) {
+        if (isInvalidRefreshTokenError(error)) {
+            clearSavedSession();
+            return null;
+        }
+        throw error;
+    }
+    const session = existingSession || readSavedSessionFromFile();
     if (!session?.access_token) {
         return null;
     }
@@ -495,6 +517,10 @@ async function refreshSessionIfNeeded(supabase) {
     }
     const { data, error } = await supabase.auth.refreshSession(session);
     if (error) {
+        if (isInvalidRefreshTokenError(error)) {
+            clearSavedSession();
+            return null;
+        }
         throw error;
     }
     const refreshed = data?.session || session;
@@ -1035,16 +1061,148 @@ function getDashboardAuthLabel(choice, loggedOut = false) {
     return email ? `Google - ${email}` : 'Google signed in';
 }
 
+function formatDashboardBytes(value) {
+    const bytes = Number(value || 0);
+    if (!Number.isFinite(bytes) || bytes <= 0) {
+        return '-';
+    }
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    let next = bytes;
+    let unitIndex = 0;
+    while (next >= 1024 && unitIndex < units.length - 1) {
+        next /= 1024;
+        unitIndex += 1;
+    }
+    const precision = next >= 100 || unitIndex === 0 ? 0 : next >= 10 ? 1 : 2;
+    return `${next.toFixed(precision)} ${units[unitIndex]}`;
+}
+
+function formatDashboardDuration(seconds) {
+    const totalSeconds = Math.max(0, Math.floor(Number(seconds || 0)));
+    const days = Math.floor(totalSeconds / 86400);
+    const hours = Math.floor((totalSeconds % 86400) / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    if (days > 0) {
+        return `${days}d ${hours}h`;
+    }
+    if (hours > 0) {
+        return `${hours}h ${minutes}m`;
+    }
+    return `${minutes}m`;
+}
+
+function getDashboardNetworkInfo() {
+    const rows = [];
+    const interfaces = os.networkInterfaces();
+    for (const [name, addresses] of Object.entries(interfaces)) {
+        for (const address of addresses || []) {
+            if (!address || address.internal) {
+                continue;
+            }
+            rows.push({
+                name,
+                family: address.family,
+                address: address.address,
+                cidr: address.cidr || ''
+            });
+        }
+    }
+    return rows.slice(0, 8);
+}
+
+function getDashboardDiskInfo() {
+    try {
+        const stats = statfsSync(os.homedir());
+        const totalBytes = Number(stats.blocks || 0) * Number(stats.bsize || 0);
+        const freeBytes = Number(stats.bavail || stats.bfree || 0) * Number(stats.bsize || 0);
+        const usedBytes = Math.max(0, totalBytes - freeBytes);
+        return {
+            path: os.homedir(),
+            total: formatDashboardBytes(totalBytes),
+            free: formatDashboardBytes(freeBytes),
+            used: formatDashboardBytes(usedBytes),
+            usedPercent: totalBytes > 0 ? Math.round(usedBytes * 100 / totalBytes) : 0
+        };
+    } catch {
+        return {
+            path: os.homedir(),
+            total: '-',
+            free: '-',
+            used: '-',
+            usedPercent: 0
+        };
+    }
+}
+
+function getDashboardUsername() {
+    try {
+        return os.userInfo().username || process.env.USERNAME || process.env.USER || '';
+    } catch {
+        return process.env.USERNAME || process.env.USER || '';
+    }
+}
+
+function getDashboardSystemInfo(state = {}) {
+    const totalMem = os.totalmem();
+    const freeMem = os.freemem();
+    const usedMem = Math.max(0, totalMem - freeMem);
+    const cpus = os.cpus();
+    const load = os.loadavg().map(value => Number.isFinite(value) ? Number(value.toFixed(2)) : 0);
+    const fastRuntime = getFastRuntime();
+    const fastPackaged = fastRuntime
+        ? (hasFastExecutable(fastRuntime) || hasFastDll(fastRuntime))
+        : false;
+    const agent = state.agent || {};
+    return {
+        hostname: os.hostname(),
+        platform: os.platform(),
+        release: os.release(),
+        arch: os.arch(),
+        type: os.type(),
+        user: getDashboardUsername(),
+        home: os.homedir(),
+        cwd: process.cwd(),
+        node: process.version,
+        packageVersion: readPackageVersion(),
+        pid: process.pid,
+        processUptime: formatDashboardDuration(process.uptime()),
+        systemUptime: formatDashboardDuration(os.uptime()),
+        cpuModel: cpus[0]?.model || '-',
+        cpuCores: cpus.length,
+        loadAverage: load.join(' / '),
+        memory: {
+            total: formatDashboardBytes(totalMem),
+            free: formatDashboardBytes(freeMem),
+            used: formatDashboardBytes(usedMem),
+            usedPercent: totalMem > 0 ? Math.round(usedMem * 100 / totalMem) : 0
+        },
+        disk: getDashboardDiskInfo(),
+        network: getDashboardNetworkInfo(),
+        runtime: {
+            requestedEngine: agent.requestedEngine || '',
+            activeEngine: agent.engine || 'pending',
+            state: agent.state || 'waiting',
+            pid: agent.pid || '',
+            command: agent.command || '',
+            args: Array.isArray(agent.args) ? agent.args.join(' ') : '',
+            runtimeId: agent.runtimeId || fastRuntime?.rid || '',
+            fastPackaged,
+            startedAt: agent.startedAt || ''
+        }
+    };
+}
+
 function renderConnectionDashboardPage(state = {}) {
     const choice = state.choice || null;
     const connectedAt = state.connectedAt || new Date().toISOString();
     const authLabel = getDashboardAuthLabel(choice, state.loggedOut);
     const manager = state.manager || (choice?.manager || '');
+    const agentState = state.agent?.state || '';
     const slot = normalizeSlotNumber(state.slot) ? `Slot ${String(state.slot).padStart(3, '0')}` : 'First available';
     const statusLabel = state.loggedOut
         ? 'Signed out for next restart'
         : manager
-            ? 'Client starting'
+            ? agentState === 'running' ? 'Agent running' : 'Client starting'
             : 'Finding Hub';
     const message = state.message || (manager
         ? 'The LiveDesk client is running from the terminal. Keep this tab open as the local client dashboard.'
@@ -1057,7 +1215,8 @@ function renderConnectionDashboardPage(state = {}) {
         slot,
         startup: Boolean(state.startup),
         completed: true,
-        statusLabel
+        statusLabel,
+        system: getDashboardSystemInfo(state)
     }).replaceAll('<', '\\u003c');
 
     return `<!doctype html>
@@ -1073,22 +1232,24 @@ function renderConnectionDashboardPage(state = {}) {
     body {
       min-height: 100vh;
       display: grid;
-      place-items: center;
-      padding: 28px;
+      align-items: stretch;
+      padding: 18px;
       background:
-        radial-gradient(circle at 78% 10%, rgba(203, 213, 225, 0.46), transparent 24%),
+        radial-gradient(circle at 84% 0%, rgba(203, 213, 225, 0.36), transparent 26%),
         linear-gradient(180deg, #f8fafc, #eef2f7);
       color: #111827;
     }
     main {
-      width: min(920px, 100%);
+      width: min(1280px, 100%);
+      min-height: calc(100vh - 36px);
+      margin: 0 auto;
       display: grid;
-      grid-template-columns: minmax(280px, 0.88fr) minmax(320px, 1.12fr);
-      overflow: hidden;
+      grid-template-columns: minmax(286px, 0.74fr) minmax(640px, 1.26fr);
       border: 1px solid rgba(148, 163, 184, 0.28);
-      border-radius: 18px;
+      border-radius: 20px;
       background: rgba(255, 255, 255, 0.92);
       box-shadow: 0 36px 110px rgba(15, 23, 42, 0.14);
+      overflow: hidden;
     }
     .hero {
       display: grid;
@@ -1144,10 +1305,14 @@ function renderConnectionDashboardPage(state = {}) {
     }
     .panel {
       display: grid;
-      gap: 16px;
-      padding: 34px;
+      align-content: start;
+      gap: 14px;
+      padding: 24px;
+      background:
+        linear-gradient(180deg, rgba(248, 250, 252, 0.78), rgba(241, 245, 249, 0.72)),
+        #f8fafc;
     }
-    .status-card {
+    .status-card, .section-card {
       display: grid;
       gap: 14px;
       padding: 18px;
@@ -1158,6 +1323,7 @@ function renderConnectionDashboardPage(state = {}) {
         0 20px 50px rgba(15, 23, 42, 0.09),
         0 1px 0 rgba(255, 255, 255, 0.9) inset;
     }
+    .section-card { gap: 12px; }
     .status-head {
       display: flex;
       align-items: center;
@@ -1191,6 +1357,17 @@ function renderConnectionDashboardPage(state = {}) {
       font-size: 20px;
       line-height: 1.18;
     }
+    .section-title {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 12px;
+      color: #0f172a;
+      font-size: 12px;
+      font-weight: 850;
+      letter-spacing: 0.04em;
+      text-transform: uppercase;
+    }
     dl {
       display: grid;
       grid-template-columns: 118px minmax(0, 1fr);
@@ -1213,6 +1390,91 @@ function renderConnectionDashboardPage(state = {}) {
       text-overflow: ellipsis;
       white-space: nowrap;
     }
+    .hero-metrics, .metric-grid {
+      display: grid;
+      grid-template-columns: repeat(2, minmax(0, 1fr));
+      gap: 10px;
+    }
+    .hero-metric, .metric-card {
+      display: grid;
+      gap: 6px;
+      min-height: 68px;
+      padding: 12px;
+      border: 1px solid rgba(148, 163, 184, 0.24);
+      border-radius: 12px;
+      background: rgba(255, 255, 255, 0.78);
+      box-shadow: 0 12px 30px rgba(15, 23, 42, 0.06);
+    }
+    .hero-metric span, .metric-card span {
+      color: #64748b;
+      font-size: 11px;
+      font-weight: 780;
+      letter-spacing: 0.04em;
+      text-transform: uppercase;
+    }
+    .hero-metric strong, .metric-card strong {
+      min-width: 0;
+      overflow: hidden;
+      color: #0f172a;
+      font-size: 18px;
+      font-weight: 780;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+    .progress {
+      width: 100%;
+      height: 4px;
+      overflow: hidden;
+      border-radius: 999px;
+      background: #e2e8f0;
+    }
+    .progress i {
+      display: block;
+      width: 0%;
+      height: 100%;
+      border-radius: inherit;
+      background: #111827;
+      transition: width 180ms ease;
+    }
+    .info-grid {
+      display: grid;
+      grid-template-columns: repeat(2, minmax(0, 1fr));
+      gap: 9px 14px;
+    }
+    .info-item {
+      min-width: 0;
+      display: grid;
+      gap: 3px;
+    }
+    .info-item span, .network-row span {
+      color: #64748b;
+      font-size: 11px;
+      font-weight: 760;
+    }
+    .info-item strong, .network-row strong {
+      min-width: 0;
+      overflow: hidden;
+      color: #111827;
+      font-size: 13px;
+      font-weight: 720;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+    .network-list {
+      display: grid;
+      gap: 7px;
+    }
+    .network-row {
+      display: grid;
+      grid-template-columns: minmax(88px, 0.45fr) minmax(0, 1fr);
+      gap: 12px;
+      min-height: 32px;
+      align-items: center;
+      padding: 8px 10px;
+      border: 1px solid rgba(148, 163, 184, 0.24);
+      border-radius: 9px;
+      background: #f8fafc;
+    }
     .actions {
       display: grid;
       grid-template-columns: 1fr 1fr;
@@ -1256,6 +1518,7 @@ function renderConnectionDashboardPage(state = {}) {
       .hero, .panel { padding: 24px; }
       h1 { font-size: 28px; }
       .actions { grid-template-columns: 1fr; }
+      .hero-metrics, .metric-grid, .info-grid { grid-template-columns: 1fr; }
     }
   </style>
 </head>
@@ -1274,6 +1537,26 @@ function renderConnectionDashboardPage(state = {}) {
         <h1>Client is ready</h1>
         <p id="message">${escapeHtml(message)}</p>
       </div>
+      <div class="hero-metrics">
+        <div class="hero-metric">
+          <span>Host</span>
+          <strong id="hero-host">-</strong>
+        </div>
+        <div class="hero-metric">
+          <span>Engine</span>
+          <strong id="hero-engine">pending</strong>
+        </div>
+        <div class="hero-metric">
+          <span>Memory</span>
+          <strong id="hero-memory">-</strong>
+          <div class="progress"><i id="memory-bar"></i></div>
+        </div>
+        <div class="hero-metric">
+          <span>Disk</span>
+          <strong id="hero-disk">-</strong>
+          <div class="progress"><i id="disk-bar"></i></div>
+        </div>
+      </div>
       <p>Keep this page open if you want a local control surface for this workstation. Reboots can reconnect automatically when startup is enabled.</p>
     </section>
     <section class="panel">
@@ -1290,6 +1573,47 @@ function renderConnectionDashboardPage(state = {}) {
           <dt>Started</dt><dd id="connected-at">${escapeHtml(connectedAt)}</dd>
         </dl>
       </article>
+      <article class="section-card">
+        <div class="section-title">System</div>
+        <div class="metric-grid">
+          <div class="metric-card"><span>CPU</span><strong id="cpu-model">-</strong></div>
+          <div class="metric-card"><span>Cores</span><strong id="cpu-cores">-</strong></div>
+          <div class="metric-card"><span>OS</span><strong id="os-line">-</strong></div>
+          <div class="metric-card"><span>Uptime</span><strong id="system-uptime">-</strong></div>
+          <div class="metric-card"><span>Load avg</span><strong id="load-average">-</strong></div>
+          <div class="metric-card"><span>Architecture</span><strong id="arch-line">-</strong></div>
+        </div>
+      </article>
+      <article class="section-card">
+        <div class="section-title">Runtime</div>
+        <div class="info-grid">
+          <div class="info-item"><span>Agent state</span><strong id="agent-state">waiting</strong></div>
+          <div class="info-item"><span>Agent PID</span><strong id="agent-pid">-</strong></div>
+          <div class="info-item"><span>Runtime</span><strong id="runtime-id">-</strong></div>
+          <div class="info-item"><span>Fast package</span><strong id="fast-packaged">-</strong></div>
+          <div class="info-item"><span>Client PID</span><strong id="client-pid">-</strong></div>
+          <div class="info-item"><span>Node</span><strong id="node-version">-</strong></div>
+          <div class="info-item"><span>Package</span><strong id="package-version">-</strong></div>
+          <div class="info-item"><span>Process uptime</span><strong id="process-uptime">-</strong></div>
+          <div class="info-item"><span>Agent started</span><strong id="agent-started">-</strong></div>
+        </div>
+      </article>
+      <article class="section-card">
+        <div class="section-title">Storage & Paths</div>
+        <div class="info-grid">
+          <div class="info-item"><span>Disk used</span><strong id="disk-used">-</strong></div>
+          <div class="info-item"><span>Disk free</span><strong id="disk-free">-</strong></div>
+          <div class="info-item"><span>User</span><strong id="user-name">-</strong></div>
+          <div class="info-item"><span>Home</span><strong id="home-path">-</strong></div>
+          <div class="info-item"><span>Working dir</span><strong id="cwd-path">-</strong></div>
+          <div class="info-item"><span>Agent command</span><strong id="agent-command">-</strong></div>
+          <div class="info-item"><span>Agent args</span><strong id="agent-args">-</strong></div>
+        </div>
+      </article>
+      <article class="section-card">
+        <div class="section-title">Network</div>
+        <div id="network-list" class="network-list"></div>
+      </article>
       <div class="actions">
         <a class="button secondary" href="/">Refresh dashboard</a>
         <form method="post" action="/logout">
@@ -1305,7 +1629,33 @@ function renderConnectionDashboardPage(state = {}) {
       const node = document.getElementById(id);
       if (node) node.textContent = value || '';
     }
+    function setBar(id, value) {
+      const node = document.getElementById(id);
+      if (!node) return;
+      const percent = Math.max(0, Math.min(100, Number(value) || 0));
+      node.style.width = percent + '%';
+    }
+    function renderNetworkRows(items) {
+      const list = document.getElementById('network-list');
+      if (!list) return;
+      list.textContent = '';
+      const rows = Array.isArray(items) && items.length > 0 ? items : [{ name: 'Network', address: 'not reported', family: '' }];
+      for (const item of rows) {
+        const row = document.createElement('div');
+        row.className = 'network-row';
+        const name = document.createElement('span');
+        name.textContent = [item.name, item.family].filter(Boolean).join(' / ');
+        const address = document.createElement('strong');
+        address.textContent = item.cidr || item.address || 'not reported';
+        row.append(name, address);
+        list.append(row);
+      }
+    }
     function applyState(state) {
+      const system = state.system || {};
+      const memory = system.memory || {};
+      const disk = system.disk || {};
+      const runtime = system.runtime || {};
       setText('status', state.statusLabel || initialState.statusLabel);
       setText('auth', state.authLabel || initialState.authLabel);
       setText('manager', state.manager || 'waiting');
@@ -1313,6 +1663,35 @@ function renderConnectionDashboardPage(state = {}) {
       setText('startup', state.startup ? 'enabled' : 'manual');
       setText('connected-at', state.connectedAt || initialState.connectedAt);
       setText('message', state.message || initialState.message);
+      setText('hero-host', system.hostname || '-');
+      setText('hero-engine', runtime.activeEngine || runtime.state || 'pending');
+      setText('hero-memory', memory.used && memory.total ? memory.used + ' / ' + memory.total : '-');
+      setText('hero-disk', disk.usedPercent ? disk.usedPercent + '% used' : disk.free ? disk.free + ' free' : '-');
+      setBar('memory-bar', memory.usedPercent);
+      setBar('disk-bar', disk.usedPercent);
+      setText('cpu-model', system.cpuModel || '-');
+      setText('cpu-cores', system.cpuCores ? String(system.cpuCores) : '-');
+      setText('os-line', [system.type || system.platform, system.release, system.arch].filter(Boolean).join(' '));
+      setText('system-uptime', system.systemUptime || '-');
+      setText('load-average', system.loadAverage || '-');
+      setText('arch-line', [system.platform, system.arch].filter(Boolean).join(' / '));
+      setText('agent-state', runtime.state || 'waiting');
+      setText('agent-pid', runtime.pid ? String(runtime.pid) : '-');
+      setText('runtime-id', runtime.runtimeId || runtime.requestedEngine || '-');
+      setText('fast-packaged', runtime.fastPackaged ? 'available' : 'missing');
+      setText('client-pid', system.pid ? String(system.pid) : '-');
+      setText('node-version', system.node || '-');
+      setText('package-version', system.packageVersion || '-');
+      setText('process-uptime', system.processUptime || '-');
+      setText('agent-started', runtime.startedAt || '-');
+      setText('disk-used', disk.used && disk.total ? disk.used + ' / ' + disk.total : '-');
+      setText('disk-free', disk.free || '-');
+      setText('user-name', system.user || '-');
+      setText('home-path', system.home || '-');
+      setText('cwd-path', system.cwd || '-');
+      setText('agent-command', runtime.command || '-');
+      setText('agent-args', runtime.args || '-');
+      renderNetworkRows(system.network);
     }
     applyState(initialState);
     if (location.pathname === '/callback') {
@@ -1458,6 +1837,10 @@ async function startConnectionChoiceServer(supabase, options = {}) {
     let completedTitle = 'LiveDesk connection complete';
     let completedMessage = 'The LiveDesk client is starting automatically.';
     const dashboardState = {
+        agent: {
+            requestedEngine: options.engine || '',
+            state: 'waiting'
+        },
         choice: null,
         connectedAt: '',
         endpointCandidates: [],
@@ -1506,6 +1889,7 @@ async function startConnectionChoiceServer(supabase, options = {}) {
     });
     const getDashboardApiState = () => {
         const manager = dashboardState.manager || dashboardState.choice?.manager || '';
+        const agentState = dashboardState.agent?.state || '';
         return {
             authLabel: getDashboardAuthLabel(dashboardState.choice, dashboardState.loggedOut),
             connectedAt: dashboardState.connectedAt || '',
@@ -1517,10 +1901,11 @@ async function startConnectionChoiceServer(supabase, options = {}) {
             statusLabel: dashboardState.loggedOut
                 ? 'Signed out for next restart'
                 : manager
-                    ? 'Client starting'
+                    ? agentState === 'running' ? 'Agent running' : 'Client starting'
                     : completed
                         ? 'Finding Hub'
-                        : 'Waiting for auth'
+                        : 'Waiting for auth',
+            system: getDashboardSystemInfo(dashboardState)
         };
     };
 
@@ -1588,7 +1973,7 @@ async function startConnectionChoiceServer(supabase, options = {}) {
                     await supabase.auth.signOut();
                 } catch {
                 }
-                rmSync(CLIENT_AUTH_PATH, { force: true });
+                clearSavedSession();
                 clearSavedPin();
                 dashboardState.choice = null;
                 dashboardState.loggedOut = true;
@@ -1621,11 +2006,22 @@ async function startConnectionChoiceServer(supabase, options = {}) {
 
             if (requestUrl.pathname === '/google') {
                 pendingStartup = normalizeStartupChoice(requestUrl.searchParams.get('startup'), pendingStartup);
-                const { data: existing } = await supabase.auth.getSession();
-                if (existing?.session?.access_token) {
-                    writeSavedSessionToFile(existing.session);
+                let existingSession = null;
+                try {
+                    const { data: existing } = await supabase.auth.getSession();
+                    existingSession = existing?.session || null;
+                } catch (err) {
+                    if (isInvalidRefreshTokenError(err)) {
+                        clearSavedSession();
+                    } else {
+                        handleError(res, err);
+                        return;
+                    }
+                }
+                if (existingSession?.access_token) {
+                    writeSavedSessionToFile(existingSession);
                     applyStartupPreference(pendingStartup, startupArgs);
-                    const choice = { type: 'google', session: existing.session };
+                    const choice = { type: 'google', session: existingSession };
                     complete(choice, 'LiveDesk client dashboard', 'Signed in. The client is starting automatically.');
                     res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
                     res.end(renderDashboard());
@@ -1789,6 +2185,7 @@ async function chooseClientConnection(supabase, options = {}) {
     const connectionPage = await startConnectionChoiceServer(supabase, {
         authPort: options.authPort,
         autoGoogle: options.autoGoogle,
+        engine: options.engine,
         slot: options.slot,
         startupArgs: options.startupArgs,
         savedSession: options.savedSession,
@@ -1944,6 +2341,7 @@ async function prepareLoginConnection(parsed) {
             choice = await chooseClientConnection(supabase, {
                 authPort: parsed.authPort,
                 autoGoogle: !savedSession?.access_token && !savedPin,
+                engine: parsed.engine,
                 slot: parsed.slot,
                 startupArgs,
                 savedSession,
@@ -2169,6 +2567,27 @@ function buildFastArgs(args, fakeThumbnail) {
     return forwarded;
 }
 
+function redactAgentArgs(args = []) {
+    const redacted = [];
+    const secretFlags = new Set(['--pair', '--token', '--key']);
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = String(args[index] || '');
+        const equalsIndex = arg.indexOf('=');
+        if (equalsIndex > 0 && secretFlags.has(arg.slice(0, equalsIndex))) {
+            redacted.push(`${arg.slice(0, equalsIndex)}=<hidden>`);
+            continue;
+        }
+        redacted.push(arg);
+        if (secretFlags.has(arg)) {
+            if (index + 1 < args.length) {
+                redacted.push('<hidden>');
+                index += 1;
+            }
+        }
+    }
+    return redacted;
+}
+
 function resolveFastLaunch(runtime) {
     if (!runtime) {
         return {
@@ -2217,12 +2636,15 @@ function resolveFastLaunch(runtime) {
     };
 }
 
-function spawnAgent(command, args, env = process.env) {
+function spawnAgent(command, args, env = process.env, onStart = null) {
     const child = spawn(command, args, {
         env,
         stdio: 'inherit',
         windowsHide: true
     });
+    if (typeof onStart === 'function') {
+        onStart(child);
+    }
 
     return new Promise(resolve => {
         child.once('error', error => {
@@ -2267,22 +2689,88 @@ async function main() {
         const prepared = await prepareLoginConnection(parsed);
         const fastRuntime = getFastRuntime();
         const useFast = shouldTryFast(prepared, fastRuntime);
+        const updateAgentDashboard = (patch = {}) => {
+            prepared.connectionPage?.update({
+                agent: {
+                    requestedEngine: prepared.engine,
+                    state: 'launching',
+                    ...patch
+                },
+                message: patch.state === 'running'
+                    ? `LiveDesk client agent is running with ${patch.engine || 'agent'} mode.`
+                    : 'LiveDesk client agent is launching.'
+            });
+        };
         let result;
         if (useFast) {
             const fastArgs = buildFastArgs(prepared.forwarded, prepared.fakeThumbnail);
             const fastLaunch = resolveFastLaunch(fastRuntime);
             if (fastLaunch.ok) {
-                result = await spawnAgent(fastLaunch.command, [...fastLaunch.argsPrefix, ...fastArgs], buildFastEnvironment());
+                const launchArgs = [...fastLaunch.argsPrefix, ...fastArgs];
+                updateAgentDashboard({
+                    engine: 'fast',
+                    command: fastLaunch.command,
+                    args: redactAgentArgs(launchArgs),
+                    runtimeId: fastRuntime?.rid || '',
+                    state: 'launching'
+                });
+                result = await spawnAgent(fastLaunch.command, launchArgs, buildFastEnvironment(), child => {
+                    updateAgentDashboard({
+                        engine: 'fast',
+                        command: fastLaunch.command,
+                        args: redactAgentArgs(launchArgs),
+                        runtimeId: fastRuntime?.rid || '',
+                        pid: child.pid,
+                        startedAt: new Date().toISOString(),
+                        state: 'running'
+                    });
+                });
             } else if (prepared.engine === 'fast') {
                 console.error(`C# RemoteFast is unavailable: ${fastLaunch.reason}. Use --engine node to run the legacy Node agent.`);
                 prepared.connectionPage?.close?.();
                 process.exit(2);
             } else {
                 console.warn(`C# RemoteFast is unavailable (${fastLaunch.reason}). Falling back to the Node remote agent.`);
-                result = await spawnAgent(process.execPath, [nodeAgentPath, ...prepared.forwarded]);
+                const launchArgs = [nodeAgentPath, ...prepared.forwarded];
+                updateAgentDashboard({
+                    engine: 'node',
+                    command: process.execPath,
+                    args: redactAgentArgs(launchArgs),
+                    runtimeId: 'node-fallback',
+                    state: 'launching'
+                });
+                result = await spawnAgent(process.execPath, launchArgs, process.env, child => {
+                    updateAgentDashboard({
+                        engine: 'node',
+                        command: process.execPath,
+                        args: redactAgentArgs(launchArgs),
+                        runtimeId: 'node-fallback',
+                        pid: child.pid,
+                        startedAt: new Date().toISOString(),
+                        state: 'running'
+                    });
+                });
             }
         } else {
-            result = await spawnAgent(process.execPath, [nodeAgentPath, ...prepared.forwarded]);
+            const launchArgs = [nodeAgentPath, ...prepared.forwarded];
+            updateAgentDashboard({
+                engine: 'node',
+                command: process.execPath,
+                args: redactAgentArgs(launchArgs),
+                runtimeId: 'node',
+                state: 'launching'
+            });
+            result = await spawnAgent(process.execPath, launchArgs, process.env, child => {
+                updateAgentDashboard({
+                    engine: 'node',
+                    command: process.execPath,
+                    args: redactAgentArgs(launchArgs),
+                    runtimeId: 'node',
+                    pid: child.pid,
+                    startedAt: new Date().toISOString(),
+                    state: 'running'
+                });
+            });
         }
         prepared.connectionPage?.close?.();
         if (result?.signal) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/client",
-  "version": "0.1.63",
+  "version": "0.1.65",
   "description": "LiveDesk local remote client",
   "type": "module",
   "bin": {