@livedesk/client 0.1.0 → 0.1.1

package/README.md

@@ -3,18 +3,26 @@
 Run a direct LiveDesk remote client from a controlled computer.
 
 ```powershell
-npx @livedesk/client connect --manager 127.0.0.1:5197 --pair <token>
+npx @livedesk/client connect
 ```
 
-For LAN use, start `@livedesk/hub` with an externally reachable RemoteHub host
-and point clients at that address:
+The default flow opens Google sign-in, finds the active LiveDesk manager
+published by the same account, and asks for a computer number to place this
+machine on the screen wall.
+
+On the manager computer, open the LiveDesk dashboard and sign in first. The
+dashboard keeps its local hub address and private pair token refreshed in the
+LiveDesk Supabase registry for the signed-in account.
+
+For manual LAN fallback, start `@livedesk/hub` with an externally reachable
+RemoteHub host and pass the address/token explicitly:
 
 ```powershell
 $env:REMOTE_HUB_HOST="0.0.0.0"
 $env:REMOTE_HUB_PORT="5197"
 npm run dev:hub
 
-npx @livedesk/client connect --manager 192.168.0.10:5197 --pair <strong-token>
+npx @livedesk/client connect --no-login --manager 192.168.0.10:5197 --pair <strong-token> --slot 2
 ```
 
 The client registers the device, sends status heartbeats, can return
@@ -28,9 +36,10 @@ is unavailable.
 Useful flags:
 
 ```powershell
-npx @livedesk/client connect --manager 127.0.0.1:5197 --pair <token> --no-thumbnail
-npx @livedesk/client connect --manager 127.0.0.1:5197 --pair <token> --no-live
-npx @livedesk/client connect --manager 127.0.0.1:5197 --pair <token> --engine node
-npx @livedesk/client connect --manager 127.0.0.1:5197 --pair <token> --engine fast
-npx @livedesk/client connect --manager 127.0.0.1:5197 --pair <token> --engine fast --trace-frames
+npx @livedesk/client connect --slot 3
+npx @livedesk/client connect --no-thumbnail
+npx @livedesk/client connect --no-live
+npx @livedesk/client connect --engine node
+npx @livedesk/client connect --engine fast --trace-frames
+npx @livedesk/client connect --logout
 ```

package/bin/livedesk-client-node.js

@@ -25,6 +25,7 @@ Usage:
 Options:
   --manager <host:port>  RemoteHub address. Default: ${DEFAULT_MANAGER}
   --pair <token>         RemoteHub pairing token. Can also use LIVEDESK_CLIENT_PAIR_TOKEN.
+  --slot <number>        Screen wall slot number for this computer.
   --name <name>          Friendly device name. Default: OS hostname.
   --heartbeat <ms>       Status heartbeat interval. Default: ${DEFAULT_HEARTBEAT_MS}
   --device-id <id>       Stable device id. Default: generated and saved per OS user.
@@ -60,6 +61,7 @@ function parseArgs(argv) {
         command: 'connect',
         manager: process.env.LIVEDESK_CLIENT_MANAGER || process.env.MINDEXEC_REMOTE_MANAGER || DEFAULT_MANAGER,
         pair: process.env.LIVEDESK_CLIENT_PAIR_TOKEN || process.env.MINDEXEC_REMOTE_PAIR_TOKEN || '',
+        slotNumber: normalizeSlotNumber(process.env.LIVEDESK_CLIENT_SLOT || process.env.MINDEXEC_REMOTE_SLOT),
         name: process.env.LIVEDESK_CLIENT_NAME || process.env.MINDEXEC_REMOTE_NAME || os.hostname(),
         heartbeatMs: DEFAULT_HEARTBEAT_MS,
         deviceId: '',
@@ -91,6 +93,9 @@ function parseArgs(argv) {
             case '--pair':
                 result.pair = args[++index] || '';
                 break;
+            case '--slot':
+                result.slotNumber = normalizeSlotNumber(args[++index] || result.slotNumber);
+                break;
             case '--name':
                 result.name = args[++index] || result.name;
                 break;
@@ -186,6 +191,11 @@ function normalizeDeviceId(value) {
     return String(value || '').trim().replace(/[^a-zA-Z0-9_.:-]/g, '-').slice(0, 128);
 }
 
+function normalizeSlotNumber(value) {
+    const number = Number(String(value || '').trim());
+    return Number.isInteger(number) && number >= 1 && number <= 99 ? number : 0;
+}
+
 async function getDeviceId(explicitDeviceId = '') {
     const explicit = normalizeDeviceId(explicitDeviceId);
     if (explicit) {
@@ -213,10 +223,10 @@ async function getDeviceId(explicitDeviceId = '') {
     return deviceId;
 }
 
-function getStatus() {
+function getStatus(options = {}) {
     const totalMem = os.totalmem();
     const freeMem = os.freemem();
-    return {
+    const status = {
         uptimeSec: Math.round(os.uptime()),
         loadavg: os.loadavg(),
         totalMem,
@@ -226,6 +236,10 @@ function getStatus() {
         release: os.release(),
         timestamp: new Date().toISOString()
     };
+    if (options.slotNumber) {
+        status.slotNumber = options.slotNumber;
+    }
+    return status;
 }
 
 function writeJsonLine(socket, payload) {
@@ -797,6 +811,7 @@ function connectOnce(options, deviceId) {
                 pairToken: options.pair,
                 deviceId,
                 deviceName: options.name,
+                slotNumber: options.slotNumber || undefined,
                 hostname: os.hostname(),
                 platform: os.platform(),
                 arch: os.arch(),
@@ -833,7 +848,7 @@ function connectOnce(options, deviceId) {
                     console.log(`Connected to RemoteHub as ${options.name} (${deviceId})`);
                     writeJsonLine(socket, {
                         type: 'status',
-                        status: getStatus()
+                        status: getStatus(options)
                     });
                     if (options.once) {
                         finish();
@@ -843,7 +858,7 @@ function connectOnce(options, deviceId) {
                     heartbeatTimer = setInterval(() => {
                         writeJsonLine(socket, {
                             type: 'status',
-                            status: getStatus()
+                            status: getStatus(options)
                         });
                     }, options.heartbeatMs);
                 } else if (message.type === 'command') {

package/bin/livedesk-client.js

@@ -1,34 +1,61 @@
 #!/usr/bin/env node
 
-import { chmodSync, existsSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn, spawnSync } from 'node:child_process';
+import { createServer } from 'node:http';
+import net from 'node:net';
 import os from 'node:os';
+import { createInterface } from 'node:readline/promises';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const packageRoot = resolve(__dirname, '..');
 const nodeAgentPath = join(__dirname, 'livedesk-client-node.js');
 const FAST_PREFLIGHT_TIMEOUT_MS = 5000;
+const DEFAULT_MANAGER = '127.0.0.1:5197';
+const SUPABASE_URL = process.env.LIVEDESK_SUPABASE_URL || 'https://otbyfkjxrkngvjziawki.supabase.co';
+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_AUTH_STORAGE_KEY = 'livedesk.client.supabase.auth';
 
 function printHelp() {
-    const result = spawnSync(process.execPath, [nodeAgentPath, '--help'], {
-        encoding: 'utf8'
-    });
-    const help = result.stdout || '';
-    process.stdout.write(`${help}
+    process.stdout.write(`
+LiveDesk Client
+
+Usage:
+  npx @livedesk/client connect
 
-Engine selection:
+Default flow:
+  Opens Google sign-in, finds the signed-in manager, asks for this computer's
+  screen-wall number, then connects locally.
+
+Options:
+  --slot <number>                 Screen wall slot number for this computer.
+  --name <name>                   Friendly device name. Default: OS hostname.
   --engine auto|fast|csharp|node  Select agent engine. Default: auto.
   --fast                          Force C# RemoteFast frame.binary engine.
   --node                          Force the legacy Node agent.
   --control                       Enable RemoteFast keyboard/mouse control.
   --no-control                    Disable RemoteFast keyboard/mouse control.
-  --transport ws|tcp              RemoteFast hub transport. Default: ws.
+  --thumbnail                     Enable thumbnail capture when supported.
+  --no-thumbnail                  Disable thumbnail capture capability.
+  --live                          Enable focused live screen streaming.
+  --no-live                       Disable focused live screen streaming.
+  --tasks                         Enable safe remote task inbox.
+  --no-tasks                      Disable remote task dispatch capability.
+  --login                         Sign in with Google and auto-discover manager.
+  --logout                        Forget saved Google session before connecting.
+  --version                       Show the agent version.
+  --help                          Show this help.
+
+Manual fallback:
+  npx @livedesk/client connect --no-login --manager 192.168.0.10:5197 --pair <token> --slot 2
 
 Auto uses C# RemoteFast when supported and falls back to Node for AI assist or
 when a packaged RemoteFast runtime is unavailable.
-`);
+`.trimStart());
 }
 
 function normalizeEngine(value) {
@@ -46,11 +73,27 @@ function parseLauncherArgs(argv) {
     const forwarded = [];
     let engine = normalizeEngine(process.env.LIVEDESK_CLIENT_ENGINE || process.env.MINDEXEC_REMOTE_ENGINE);
     let help = false;
+    let loginRequested = false;
+    let loginDisabled = false;
+    let logout = false;
+    let manager = process.env.LIVEDESK_CLIENT_MANAGER || process.env.MINDEXEC_REMOTE_MANAGER || '';
+    let pair = process.env.LIVEDESK_CLIENT_PAIR_TOKEN || process.env.MINDEXEC_REMOTE_PAIR_TOKEN || '';
+    let slot = process.env.LIVEDESK_CLIENT_SLOT || process.env.MINDEXEC_REMOTE_SLOT || '';
+    let command = 'connect';
     let nodeOnlyFeature = false;
     let fakeThumbnail = false;
 
+    const args = [...argv];
+    if (args[0] && !args[0].startsWith('-')) {
+        command = args[0];
+    }
+
     for (let index = 0; index < argv.length; index += 1) {
         const arg = argv[index];
+        if (index === 0 && arg && !arg.startsWith('-')) {
+            forwarded.push(arg);
+            continue;
+        }
         if (arg === '--engine') {
             engine = normalizeEngine(argv[index + 1]);
             index += 1;
@@ -64,6 +107,36 @@ function parseLauncherArgs(argv) {
             engine = 'node';
             continue;
         }
+        if (arg === '--login') {
+            loginRequested = true;
+            continue;
+        }
+        if (arg === '--no-login') {
+            loginDisabled = true;
+            continue;
+        }
+        if (arg === '--logout') {
+            logout = true;
+            continue;
+        }
+        if (arg === '--manager') {
+            manager = argv[index + 1] || manager;
+            forwarded.push(arg, argv[index + 1]);
+            index += 1;
+            continue;
+        }
+        if (arg === '--pair') {
+            pair = argv[index + 1] || pair;
+            forwarded.push(arg, argv[index + 1]);
+            index += 1;
+            continue;
+        }
+        if (arg === '--slot') {
+            slot = argv[index + 1] || slot;
+            forwarded.push(arg, argv[index + 1]);
+            index += 1;
+            continue;
+        }
 
         if (arg === '--help' || arg === '-h') {
             help = true;
@@ -81,11 +154,304 @@ function parseLauncherArgs(argv) {
         engine,
         forwarded,
         help,
+        command,
+        loginRequested,
+        loginDisabled,
+        logout,
+        manager,
+        pair,
+        slot,
         nodeOnlyFeature,
         fakeThumbnail
     };
 }
 
+function normalizeSlotNumber(value) {
+    const number = Number(String(value || '').trim());
+    if (!Number.isInteger(number) || number < 1 || number > 99) {
+        return '';
+    }
+    return String(number);
+}
+
+function upsertForwardedOption(args, flag, value) {
+    if (!value) {
+        return args;
+    }
+    const next = [...args];
+    const index = next.indexOf(flag);
+    if (index >= 0) {
+        next[index + 1] = value;
+        return next;
+    }
+    next.push(flag, value);
+    return next;
+}
+
+function createFileStorage(filePath) {
+    function readState() {
+        try {
+            return JSON.parse(readFileSync(filePath, 'utf8'));
+        } catch {
+            return {};
+        }
+    }
+
+    function writeState(state) {
+        mkdirSync(dirname(filePath), { recursive: true });
+        writeFileSync(filePath, JSON.stringify(state, null, 2));
+    }
+
+    return {
+        getItem(key) {
+            const state = readState();
+            return typeof state[key] === 'string' ? state[key] : null;
+        },
+        setItem(key, value) {
+            const state = readState();
+            state[key] = String(value);
+            writeState(state);
+        },
+        removeItem(key) {
+            const state = readState();
+            delete state[key];
+            writeState(state);
+        }
+    };
+}
+
+async function createSupabaseClient() {
+    const { createClient } = await import('@supabase/supabase-js');
+    return createClient(SUPABASE_URL, SUPABASE_PUBLISHABLE_KEY, {
+        auth: {
+            autoRefreshToken: false,
+            persistSession: true,
+            detectSessionInUrl: false,
+            flowType: 'pkce',
+            storageKey: CLIENT_AUTH_STORAGE_KEY,
+            storage: createFileStorage(CLIENT_AUTH_PATH)
+        }
+    });
+}
+
+function openBrowser(url) {
+    if (os.platform() === 'win32') {
+        spawn('cmd', ['/c', 'start', '', url], { detached: true, stdio: 'ignore', windowsHide: true }).unref();
+        return;
+    }
+    const command = os.platform() === 'darwin' ? 'open' : 'xdg-open';
+    spawn(command, [url], { detached: true, stdio: 'ignore' }).unref();
+}
+
+async function startOAuthCallbackServer() {
+    let settleCode;
+    let rejectCode;
+    const waitForCode = new Promise((resolve, reject) => {
+        settleCode = resolve;
+        rejectCode = reject;
+    });
+    const server = createServer((req, res) => {
+            const requestUrl = new URL(req.url || '/', `http://127.0.0.1:${server.address().port}`);
+            const code = requestUrl.searchParams.get('code');
+            const error = requestUrl.searchParams.get('error_description') || requestUrl.searchParams.get('error');
+            if (error) {
+                res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end('<h1>LiveDesk sign-in failed</h1><p>You can close this tab.</p>');
+                rejectCode(new Error(error));
+                server.close();
+                return;
+            }
+            if (!code) {
+                res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+                res.end('LiveDesk sign-in callback is waiting for an auth code.');
+                return;
+            }
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end('<h1>LiveDesk sign-in complete</h1><p>You can close this tab and return to the terminal.</p>');
+            settleCode(code);
+            server.close();
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', resolve);
+    });
+    return {
+        get redirectTo() {
+            return `http://127.0.0.1:${server.address().port}/callback`;
+        },
+        waitForCode
+    };
+}
+
+async function signInWithGoogle(supabase) {
+    const { data: existing } = await supabase.auth.getSession();
+    if (existing?.session?.access_token) {
+        return existing.session;
+    }
+
+    const callback = await startOAuthCallbackServer();
+    const { data, error } = await supabase.auth.signInWithOAuth({
+        provider: 'google',
+        options: {
+            redirectTo: callback.redirectTo,
+            scopes: 'email profile'
+        }
+    });
+    if (error) {
+        throw error;
+    }
+    if (!data?.url) {
+        throw new Error('Supabase did not return a Google sign-in URL.');
+    }
+
+    console.log('Opening Google sign-in for LiveDesk...');
+    openBrowser(data.url);
+    const code = await callback.waitForCode;
+    const { data: sessionData, error: exchangeError } = await supabase.auth.exchangeCodeForSession(code);
+    if (exchangeError) {
+        throw exchangeError;
+    }
+    if (!sessionData?.session) {
+        throw new Error('Google sign-in did not return a LiveDesk session.');
+    }
+    return sessionData.session;
+}
+
+function parseManagerEndpoint(value) {
+    let text = String(value || '').trim().replace(/^tcp:\/\//i, '');
+    const separator = text.lastIndexOf(':');
+    if (separator <= 0) {
+        return null;
+    }
+    const host = text.slice(0, separator).replace(/^\[/, '').replace(/\]$/, '').trim();
+    const port = Number(text.slice(separator + 1));
+    if (!host || !Number.isFinite(port)) {
+        return null;
+    }
+    return { host, port };
+}
+
+function canConnectToEndpoint(endpoint, timeoutMs = 1200) {
+    const parsedEndpoint = parseManagerEndpoint(endpoint);
+    if (!parsedEndpoint) {
+        return Promise.resolve(false);
+    }
+    return new Promise(resolve => {
+        const socket = net.createConnection(parsedEndpoint);
+        const finish = ok => {
+            socket.removeAllListeners();
+            socket.destroy();
+            resolve(ok);
+        };
+        socket.setTimeout(timeoutMs);
+        socket.once('connect', () => finish(true));
+        socket.once('timeout', () => finish(false));
+        socket.once('error', () => finish(false));
+    });
+}
+
+async function chooseReachableEndpoint(candidates) {
+    for (const endpoint of candidates) {
+        if (await canConnectToEndpoint(endpoint)) {
+            return endpoint;
+        }
+    }
+    return candidates[0] || DEFAULT_MANAGER;
+}
+
+function normalizeEndpointCandidates(target) {
+    const rawCandidates = [
+        target?.endpoint,
+        ...(Array.isArray(target?.endpoint_candidates) ? target.endpoint_candidates : [])
+    ];
+    return [...new Set(rawCandidates.map(value => String(value || '').trim()).filter(Boolean))];
+}
+
+async function resolveManagerFromSupabase(supabase) {
+    const { data, error } = await supabase
+        .from('livedesk_remote_host_targets')
+        .select('endpoint, endpoint_candidates, pair_token, active, expires_at, updated_at, manager_version')
+        .eq('product_key', 'livedesk')
+        .maybeSingle();
+    if (error) {
+        throw error;
+    }
+    if (!data?.active) {
+        throw new Error('No active LiveDesk manager was found for this Google account. Start LiveDesk on the manager computer and sign in there first.');
+    }
+    if (data.expires_at && Date.parse(data.expires_at) <= Date.now()) {
+        throw new Error('The LiveDesk manager record is expired. Open the manager screen again while signed in.');
+    }
+    if (!data.pair_token) {
+        throw new Error('The LiveDesk manager record is missing its private connection token.');
+    }
+    const endpointCandidates = normalizeEndpointCandidates(data);
+    if (endpointCandidates.length === 0) {
+        throw new Error('The LiveDesk manager record does not contain a reachable local address.');
+    }
+    const manager = await chooseReachableEndpoint(endpointCandidates);
+    return {
+        manager,
+        pair: data.pair_token,
+        endpointCandidates
+    };
+}
+
+async function promptForSlotNumber(currentSlot) {
+    const normalized = normalizeSlotNumber(currentSlot);
+    if (normalized || !process.stdin.isTTY || !process.stdout.isTTY) {
+        return normalized;
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await rl.question('Computer number for screen wall (1-99, Enter to skip): ');
+        return normalizeSlotNumber(answer);
+    } finally {
+        rl.close();
+    }
+}
+
+async function prepareLoginConnection(parsed) {
+    if (parsed.logout) {
+        rmSync(CLIENT_AUTH_PATH, { force: true });
+    }
+    const shouldLogin = !parsed.loginDisabled
+        && parsed.command === 'connect'
+        && (parsed.loginRequested || !parsed.pair);
+    let forwarded = [...parsed.forwarded];
+    let manager = parsed.manager;
+    let pair = parsed.pair;
+
+    if (shouldLogin) {
+        const supabase = await createSupabaseClient();
+        const session = await signInWithGoogle(supabase);
+        const email = session.user?.email ? ` as ${session.user.email}` : '';
+        console.log(`Signed in to LiveDesk${email}.`);
+        const resolved = await resolveManagerFromSupabase(supabase);
+        manager = resolved.manager;
+        pair = resolved.pair;
+        console.log(`Found LiveDesk manager at ${manager}.`);
+    }
+
+    const slot = await promptForSlotNumber(parsed.slot);
+    if (manager) {
+        forwarded = upsertForwardedOption(forwarded, '--manager', manager);
+    }
+    if (pair) {
+        forwarded = upsertForwardedOption(forwarded, '--pair', pair);
+    }
+    if (slot) {
+        forwarded = upsertForwardedOption(forwarded, '--slot', slot);
+    }
+    return {
+        ...parsed,
+        manager,
+        pair,
+        slot,
+        forwarded
+    };
+}
+
 function getFastRuntime() {
     const platform = os.platform();
     const arch = os.arch();
@@ -281,26 +647,34 @@ function shouldUseFast(parsed) {
     return !parsed.nodeOnlyFeature;
 }
 
-const parsed = parseLauncherArgs(process.argv.slice(2));
-if (parsed.help) {
-    printHelp();
-    process.exit(0);
-}
+async function main() {
+    const parsed = parseLauncherArgs(process.argv.slice(2));
+    if (parsed.help) {
+        printHelp();
+        return;
+    }
 
-const fastRuntime = getFastRuntime();
-const useFast = shouldUseFast(parsed);
-if (useFast) {
-    const fastArgs = buildFastArgs(parsed.forwarded, parsed.fakeThumbnail);
-    const fastLaunch = resolveFastLaunch(fastRuntime);
-    if (fastLaunch.ok) {
-        spawnAgent(fastLaunch.command, [...fastLaunch.argsPrefix, ...fastArgs]);
-    } else if (parsed.engine === 'fast') {
-        console.error(`C# RemoteFast is unavailable: ${fastLaunch.reason}. Use --engine node to run the legacy Node agent.`);
-        process.exit(2);
+    const prepared = await prepareLoginConnection(parsed);
+    const fastRuntime = getFastRuntime();
+    const useFast = shouldUseFast(prepared);
+    if (useFast) {
+        const fastArgs = buildFastArgs(prepared.forwarded, prepared.fakeThumbnail);
+        const fastLaunch = resolveFastLaunch(fastRuntime);
+        if (fastLaunch.ok) {
+            spawnAgent(fastLaunch.command, [...fastLaunch.argsPrefix, ...fastArgs]);
+        } else if (prepared.engine === 'fast') {
+            console.error(`C# RemoteFast is unavailable: ${fastLaunch.reason}. Use --engine node to run the legacy Node agent.`);
+            process.exit(2);
+        } else {
+            console.warn(`C# RemoteFast is unavailable (${fastLaunch.reason}). Falling back to the Node remote agent.`);
+            spawnAgent(process.execPath, [nodeAgentPath, ...prepared.forwarded]);
+        }
     } else {
-        console.warn(`C# RemoteFast is unavailable (${fastLaunch.reason}). Falling back to the Node remote agent.`);
-        spawnAgent(process.execPath, [nodeAgentPath, ...parsed.forwarded]);
+        spawnAgent(process.execPath, [nodeAgentPath, ...prepared.forwarded]);
     }
-} else {
-    spawnAgent(process.execPath, [nodeAgentPath, ...parsed.forwarded]);
 }
+
+main().catch(error => {
+    console.error(error?.message || error);
+    process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/client",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "LiveDesk local remote client",
   "type": "module",
   "bin": {
@@ -29,6 +29,7 @@
     "node": ">=20"
   },
   "dependencies": {
+    "@supabase/supabase-js": "^2.110.0",
     "node-screenshots": "^0.2.8",
     "openai": "^6.42.0"
   },