@livedesk/client 0.1.57 → 0.1.59

package/bin/livedesk-client.js

@@ -26,6 +26,7 @@ const SUPABASE_URL = process.env.LIVEDESK_SUPABASE_URL || 'https://otbyfkjxrkngv
 const SUPABASE_PUBLISHABLE_KEY = process.env.LIVEDESK_SUPABASE_PUBLISHABLE_KEY || 'sb_publishable_NpUs0RDJH2YnllsqTKO6TQ_1jTdSsNQ';
 const CLIENT_STATE_DIR = join(os.homedir(), '.livedesk-client');
 const CLIENT_AUTH_PATH = join(CLIENT_STATE_DIR, 'auth.json');
+const CLIENT_PIN_PATH = join(CLIENT_STATE_DIR, 'pin.json');
 const CLIENT_AUTH_STORAGE_KEY = 'livedesk.client.supabase.auth';
 
 function printHelp() {
@@ -39,6 +40,7 @@ Usage:
 Default flow:
   Opens a LiveDesk connection page with Google sign-in or a 6-digit PIN.
   After auth, that page stays open as this computer's client dashboard.
+  Saved Google sign-in or saved PIN starts the client automatically.
   Omit the number for first-available placement, or pass 1-999 to pin a slot.
   If no LiveDesk Hub is active yet, the client keeps checking every 5 seconds.
 
@@ -404,6 +406,29 @@ function createFileStorage(filePath) {
     };
 }
 
+function readSavedSessionFromFile() {
+    try {
+        const state = JSON.parse(readFileSync(CLIENT_AUTH_PATH, 'utf8'));
+        const raw = state?.[CLIENT_AUTH_STORAGE_KEY];
+        if (typeof raw !== 'string' || !raw.trim()) {
+            return null;
+        }
+        const session = JSON.parse(raw);
+        return session?.access_token ? session : null;
+    } catch {
+        return null;
+    }
+}
+
+function writeSavedSessionToFile(session) {
+    if (!session?.access_token || !session?.refresh_token) {
+        return false;
+    }
+    const storage = createFileStorage(CLIENT_AUTH_PATH);
+    storage.setItem(CLIENT_AUTH_STORAGE_KEY, JSON.stringify(session));
+    return true;
+}
+
 async function createSupabaseClient() {
     const { createClient } = await import('@supabase/supabase-js');
     return createClient(SUPABASE_URL, SUPABASE_PUBLISHABLE_KEY, {
@@ -459,19 +484,22 @@ function formatDiscoveryError(error) {
 
 async function refreshSessionIfNeeded(supabase) {
     const { data: existing } = await supabase.auth.getSession();
-    const session = existing?.session;
+    const session = existing?.session || readSavedSessionFromFile();
     if (!session?.access_token) {
         return null;
     }
     const expiresAt = Number(session.expires_at || 0);
     if (expiresAt <= 0 || expiresAt - Math.floor(Date.now() / 1000) > SESSION_REFRESH_SKEW_SECONDS) {
+        writeSavedSessionToFile(session);
         return session;
     }
     const { data, error } = await supabase.auth.refreshSession(session);
     if (error) {
         throw error;
     }
-    return data?.session || session;
+    const refreshed = data?.session || session;
+    writeSavedSessionToFile(refreshed);
+    return refreshed;
 }
 
 function openBrowser(url) {
@@ -941,6 +969,19 @@ function renderConnectionChoicePage({ error = '', pin = '', slot = '', startup =
       startupToggle.addEventListener('change', syncStartupFields);
       syncStartupFields();
     }
+    async function watchAutoConnection() {
+      try {
+        const response = await fetch('/api/state', { cache: 'no-store' });
+        if (!response.ok) return;
+        const state = await response.json();
+        if (state.completed) {
+          location.replace('/');
+        }
+      } catch {
+      }
+    }
+    setInterval(watchAutoConnection, 800);
+    watchAutoConnection();
   </script>
 </body>
 </html>`;
@@ -982,6 +1023,7 @@ function renderConnectionDashboardPage(state = {}) {
         message,
         slot,
         startup: Boolean(state.startup),
+        completed: true,
         statusLabel
     }).replaceAll('<', '\\u003c');
 
@@ -1263,6 +1305,32 @@ function normalizePairingPin(value) {
     return /^\d{6}$/.test(pin) ? pin : '';
 }
 
+function readSavedPin() {
+    try {
+        const state = JSON.parse(readFileSync(CLIENT_PIN_PATH, 'utf8'));
+        return normalizePairingPin(state?.pin);
+    } catch {
+        return '';
+    }
+}
+
+function writeSavedPin(pin) {
+    const normalizedPin = normalizePairingPin(pin);
+    if (!normalizedPin) {
+        return false;
+    }
+    mkdirSync(dirname(CLIENT_PIN_PATH), { recursive: true });
+    writeFileSync(CLIENT_PIN_PATH, JSON.stringify({
+        pin: normalizedPin,
+        updatedAt: new Date().toISOString()
+    }, null, 2));
+    return true;
+}
+
+function clearSavedPin() {
+    rmSync(CLIENT_PIN_PATH, { force: true });
+}
+
 function readRequestBody(req, maxBytes = 4096) {
     return new Promise((resolve, reject) => {
         let body = '';
@@ -1314,11 +1382,42 @@ async function resolveManagerFromPin(supabase, pin) {
     };
 }
 
+async function waitForManagerFromSavedPin(supabase, pin, options = {}) {
+    const intervalMs = Math.max(1000, Number(options.intervalMs || DISCOVERY_RETRY_MS));
+    const intervalSeconds = Math.max(1, Math.round(intervalMs / 1000));
+    const shouldStop = typeof options.shouldStop === 'function' ? options.shouldStop : () => false;
+    let attempts = 0;
+    let lastMessage = '';
+    console.log(`Waiting for a LiveDesk Hub from saved PIN. This client will keep trying every ${intervalSeconds}s.`);
+    while (true) {
+        if (shouldStop()) {
+            return null;
+        }
+        attempts += 1;
+        try {
+            return await resolveManagerFromPin(supabase, pin);
+        } catch (err) {
+            if (shouldStop()) {
+                return null;
+            }
+            const message = formatDiscoveryError(err);
+            if (message !== lastMessage || attempts === 1 || attempts % 6 === 0) {
+                const suffix = attempts === 1 ? '' : ` attempt ${attempts}`;
+                console.log(`Still waiting for LiveDesk Hub by saved PIN${suffix}: ${message}`);
+                lastMessage = message;
+            }
+            await sleep(intervalMs);
+        }
+    }
+}
+
 async function startConnectionChoiceServer(supabase, options = {}) {
     const host = String(process.env.LIVEDESK_CLIENT_AUTH_HOST || DEFAULT_AUTH_CALLBACK_HOST).trim() || DEFAULT_AUTH_CALLBACK_HOST;
     const port = normalizePort(options.authPort) || DEFAULT_AUTH_CALLBACK_PORT;
     const slot = normalizeSlotNumber(options.slot);
     const startupArgs = Array.isArray(options.startupArgs) ? options.startupArgs : [];
+    const savedSession = options.savedSession?.access_token ? options.savedSession : null;
+    const savedPin = normalizePairingPin(options.savedPin);
     let pendingStartup = isWindowsStartupRegistered();
     let listeningPort = port;
     let completed = false;
@@ -1379,6 +1478,7 @@ async function startConnectionChoiceServer(supabase, options = {}) {
             message: dashboardState.message || completedMessage,
             slot: normalizeSlotNumber(slot) ? `Slot ${String(slot).padStart(3, '0')}` : 'First available',
             startup: Boolean(pendingStartup),
+            completed,
             statusLabel: dashboardState.loggedOut
                 ? 'Signed out for next restart'
                 : manager
@@ -1389,6 +1489,38 @@ async function startConnectionChoiceServer(supabase, options = {}) {
         };
     };
 
+    const startSavedConnection = async () => {
+        if (completed || dashboardState.loggedOut) {
+            return;
+        }
+        if (savedSession?.access_token) {
+            applyStartupPreference(pendingStartup, startupArgs);
+            complete({ type: 'google', session: savedSession }, 'LiveDesk client dashboard', 'Saved Google sign-in found. The client is starting automatically.');
+            return;
+        }
+        if (!savedPin) {
+            return;
+        }
+        dashboardState.message = 'Saved LiveDesk PIN found. Waiting for the Hub to become reachable.';
+        try {
+            const resolved = await waitForManagerFromSavedPin(supabase, savedPin, {
+                shouldStop: () => completed || dashboardState.loggedOut
+            });
+            if (!resolved) {
+                return;
+            }
+            if (completed || dashboardState.loggedOut) {
+                return;
+            }
+            applyStartupPreference(pendingStartup, startupArgs);
+            complete({ type: 'pin', ...resolved }, 'LiveDesk client dashboard', 'Saved PIN accepted. The client is starting automatically.');
+        } catch (err) {
+            if (!completed) {
+                dashboardState.message = `Saved PIN did not connect: ${formatDiscoveryError(err)}`;
+            }
+        }
+    };
+
     const handleError = (res, error, pin = '') => {
         res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
         res.end(renderChoice({
@@ -1421,6 +1553,7 @@ async function startConnectionChoiceServer(supabase, options = {}) {
                 } catch {
                 }
                 rmSync(CLIENT_AUTH_PATH, { force: true });
+                clearSavedPin();
                 dashboardState.choice = null;
                 dashboardState.loggedOut = true;
                 dashboardState.manager = '';
@@ -1453,6 +1586,7 @@ async function startConnectionChoiceServer(supabase, options = {}) {
                 pendingStartup = normalizeStartupChoice(requestUrl.searchParams.get('startup'), pendingStartup);
                 const { data: existing } = await supabase.auth.getSession();
                 if (existing?.session?.access_token) {
+                    writeSavedSessionToFile(existing.session);
                     applyStartupPreference(pendingStartup, startupArgs);
                     const choice = { type: 'google', session: existing.session };
                     complete(choice, 'LiveDesk client dashboard', 'Signed in. The client is starting automatically.');
@@ -1494,6 +1628,7 @@ async function startConnectionChoiceServer(supabase, options = {}) {
                 pin = normalizePairingPin(pin);
                 try {
                     const resolved = await resolveManagerFromPin(supabase, pin);
+                    writeSavedPin(pin);
                     applyStartupPreference(pendingStartup, startupArgs);
                     const choice = { type: 'pin', ...resolved };
                     complete(choice, 'LiveDesk client dashboard', 'PIN accepted. The client is starting automatically.');
@@ -1545,6 +1680,7 @@ async function startConnectionChoiceServer(supabase, options = {}) {
                     server.close();
                     return;
                 }
+                writeSavedSessionToFile(sessionData.session);
                 applyStartupPreference(pendingStartup, startupArgs);
                 const choice = { type: 'google', session: sessionData.session };
                 complete(choice, 'LiveDesk client dashboard', 'Signed in. The client is starting automatically.');
@@ -1582,6 +1718,11 @@ async function startConnectionChoiceServer(supabase, options = {}) {
         });
         const address = server.address();
         listeningPort = typeof address === 'object' && address ? address.port : port;
+        if (savedSession?.access_token || savedPin) {
+            setImmediate(() => {
+                void startSavedConnection();
+            });
+        }
     } catch (err) {
         if (err?.code === 'EADDRINUSE') {
             throw new Error(`LiveDesk connection page port ${port} is already in use. Close the app using it or run with --auth-port <port> and add that callback URL in Supabase Auth redirect URLs.`);
@@ -1744,20 +1885,28 @@ async function prepareLoginConnection(parsed) {
         const supabase = await createSupabaseClient();
         const startupArgs = buildStartupClientArgs(parsed);
         let savedSession = null;
-        if (parsed.startupRun) {
-            try {
-                savedSession = await refreshSessionIfNeeded(supabase);
-            } catch (err) {
-                console.warn(`LiveDesk saved sign-in could not be refreshed: ${err?.message || err}`);
-            }
+        try {
+            savedSession = await refreshSessionIfNeeded(supabase);
+        } catch (err) {
+            console.warn(`LiveDesk saved sign-in could not be refreshed: ${err?.message || err}`);
         }
-        const choice = savedSession?.access_token
-            ? { type: 'google', session: savedSession }
-            : await chooseClientConnection(supabase, {
+        const savedPin = readSavedPin();
+        let choice = null;
+        if (parsed.startupRun && savedSession?.access_token) {
+            choice = { type: 'google', session: savedSession };
+        } else if (parsed.startupRun && savedPin) {
+            const resolved = await waitForManagerFromSavedPin(supabase, savedPin);
+            choice = { type: 'pin', ...resolved };
+        }
+        if (!choice) {
+            choice = await chooseClientConnection(supabase, {
                 authPort: parsed.authPort,
                 slot: parsed.slot,
-                startupArgs
+                startupArgs,
+                savedSession,
+                savedPin
             });
+        }
         connectionPage = choice.connectionPage || null;
         if (choice.type === 'pin') {
             manager = choice.manager;

package/package.json

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