@playcraft/cli 0.0.49 → 0.0.52

package/dist/commands/login.js

@@ -46,16 +46,37 @@ function resolveLoginBaseUrl(options) {
         DEFAULT_PLAYCRAFT_CLOUD_BASE;
     return raw.replace(/\/+$/, '');
 }
-export function createTokenHash(token) {
-    return crypto.createHash('sha256').update(token).digest('hex');
+function normalizeLoginEnvironmentUrl(raw) {
+    try {
+        const url = new URL(raw);
+        url.hash = '';
+        url.search = '';
+        url.pathname = url.pathname.replace(/\/+$/, '');
+        return url.toString().replace(/\/+$/, '');
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resolveExistingTokenForLoginTarget(globalConfig, backendUrl) {
+    const token = typeof globalConfig.token === 'string' ? globalConfig.token : undefined;
+    const storedBackendUrl = typeof globalConfig.backendUrl === 'string'
+        ? globalConfig.backendUrl
+        : typeof globalConfig.url === 'string'
+            ? globalConfig.url
+            : undefined;
+    if (!token || !storedBackendUrl)
+        return undefined;
+    const storedEnvironment = normalizeLoginEnvironmentUrl(storedBackendUrl);
+    const targetEnvironment = normalizeLoginEnvironmentUrl(backendUrl);
+    return storedEnvironment && targetEnvironment && storedEnvironment === targetEnvironment
+        ? token
+        : undefined;
 }
 export function buildCliAuthUrl(options) {
     const url = new URL('/cli-auth', options.backendUrl);
     url.searchParams.set('callback', options.callbackUrl);
     url.searchParams.set('state', options.state);
-    if (options.existingToken?.startsWith(PAT_PREFIX)) {
-        url.searchParams.set('existingTokenHash', createTokenHash(options.existingToken));
-    }
     return url.toString();
 }
 export async function renewExistingToken(options) {
@@ -80,8 +101,9 @@ export async function renewExistingToken(options) {
 }
 export async function loginCommand(options) {
     const backendUrl = resolveLoginBaseUrl(options);
+    const callbackPort = options.callbackPort ?? CALLBACK_PORT;
     const globalConfig = loadGlobalConfig();
-    const existingToken = typeof globalConfig.token === 'string' ? globalConfig.token : undefined;
+    const existingToken = resolveExistingTokenForLoginTarget(globalConfig, backendUrl);
     if (existingToken) {
         const renewed = await renewExistingToken({ backendUrl, token: existingToken });
         if (renewed) {
@@ -96,6 +118,7 @@ export async function loginCommand(options) {
     }
     const state = crypto.randomBytes(16).toString('hex');
     return new Promise((resolve, reject) => {
+        let timeout;
         const server = http.createServer((req, res) => {
             res.setHeader('Access-Control-Allow-Origin', '*');
             res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
@@ -112,34 +135,41 @@ export async function loginCommand(options) {
                     try {
                         const data = JSON.parse(body);
                         if (data.state !== state) {
-                            res.writeHead(403, { 'Content-Type': 'text/html' });
-                            res.end('<html><body><h1>Invalid state</h1></body></html>');
-                            server.close(() => {
-                                reject(new Error('State mismatch - possible CSRF attack'));
+                            res.writeHead(403, {
+                                'Content-Type': 'text/html',
+                                Connection: 'close',
+                            });
+                            res.end('<html><body><h1>Invalid state</h1></body></html>', () => {
+                                closeServer(() => {
+                                    reject(new Error('State mismatch - possible CSRF attack'));
+                                });
                             });
                             return;
                         }
                         const callbackToken = typeof data.token === 'string' ? data.token : undefined;
-                        const renewedToken = data.renewed === true ? existingToken : undefined;
-                        const tokenToSave = callbackToken || renewedToken;
-                        if (!tokenToSave) {
+                        if (!callbackToken) {
                             throw new Error('Login callback did not include a token');
                         }
                         saveGlobalConfig({
-                            token: tokenToSave,
+                            token: callbackToken,
                             url: backendUrl,
                             backendUrl,
                         });
-                        res.writeHead(200, { 'Content-Type': 'text/html' });
+                        res.writeHead(200, {
+                            'Content-Type': 'text/html',
+                            Connection: 'close',
+                        });
                         res.end('<html>' +
                             '<head><meta charset="utf-8"><title>Login Success</title></head>' +
                             '<body style="font-family:system-ui;text-align:center;padding:40px">' +
                             '<h1>CLI Login Successful</h1>' +
                             '<p>You can close this window and return to your terminal.</p>' +
-                            '</body></html>');
-                        server.close();
-                        console.log('Login successful! Token saved to ~/.playcraft/config.json');
-                        resolve();
+                            '</body></html>', () => {
+                            closeServer(() => {
+                                console.log('Login successful! Token saved to ~/.playcraft/config.json');
+                                resolve();
+                            });
+                        });
                     }
                     catch (err) {
                         const cause = err instanceof Error ? err : new Error(String(err));
@@ -150,23 +180,39 @@ export async function loginCommand(options) {
                         const userFacing = cause instanceof SyntaxError
                             ? 'Invalid JSON in login callback.'
                             : `Login callback failed: ${cause.message}`;
-                        res.writeHead(500, { 'Content-Type': 'text/html; charset=utf-8' });
+                        res.writeHead(500, {
+                            'Content-Type': 'text/html; charset=utf-8',
+                            Connection: 'close',
+                        });
                         res.end('<html><head><meta charset="utf-8"/><title>Error</title></head>' +
                             '<body style="font-family:system-ui;padding:24px">' +
                             `<h1>Error</h1><p>${escapeHtml(userFacing)}</p>` +
-                            '</body></html>');
-                        server.close(() => {
-                            reject(new Error(userFacing));
+                            '</body></html>', () => {
+                            closeServer(() => {
+                                reject(new Error(userFacing));
+                            });
                         });
                     }
                 });
             }
         });
+        const closeServer = (onClosed) => {
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = undefined;
+            }
+            if (!server.listening) {
+                onClosed();
+                return;
+            }
+            server.close(onClosed);
+            server.closeAllConnections();
+        };
         // Bind failures emit 'error' (e.g. EADDRINUSE); synchronously thrown errors from listen() are caught below.
         server.on('error', (err) => {
-            server.close(() => {
+            closeServer(() => {
                 if (err.code === 'EADDRINUSE') {
-                    reject(new Error(`Port ${CALLBACK_PORT} is already in use. ` +
+                    reject(new Error(`Port ${callbackPort} is already in use. ` +
                         'Please close any other playcraft login process and try again.'));
                 }
                 else {
@@ -175,13 +221,14 @@ export async function loginCommand(options) {
             });
         });
         try {
-            server.listen(CALLBACK_PORT, () => {
-                const callbackUrl = `http://localhost:${CALLBACK_PORT}/callback`;
+            server.listen(callbackPort, () => {
+                const address = server.address();
+                const listeningPort = typeof address === 'object' && address ? address.port : callbackPort;
+                const callbackUrl = `http://localhost:${listeningPort}/callback`;
                 const authUrl = buildCliAuthUrl({
                     backendUrl,
                     callbackUrl,
                     state,
-                    existingToken,
                 });
                 console.log('Opening browser for login...');
                 console.log(`If the browser does not open, visit this URL manually:\n  ${authUrl}\n`);
@@ -190,19 +237,22 @@ export async function loginCommand(options) {
             });
         }
         catch (err) {
-            server.close(() => {
+            closeServer(() => {
                 reject(err instanceof Error ? err : new Error(String(err)));
             });
             return;
         }
         // Timeout handler
-        const timeout = setTimeout(() => {
-            server.close(() => {
+        timeout = setTimeout(() => {
+            closeServer(() => {
                 reject(new Error('Login timed out after 5 minutes. Please try again.'));
             });
         }, TIMEOUT_MS);
         server.on('close', () => {
-            clearTimeout(timeout);
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = undefined;
+            }
         });
     });
 }