@aloth/olcli 0.1.7 → 0.2.0

package/dist/client.js

@@ -8,6 +8,8 @@ import * as cheerio from 'cheerio';
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import * as https from 'node:https';
+import * as http from 'node:http';
 // Read version from package.json
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
@@ -48,24 +50,20 @@ export class OverleafClient {
             [cookieName]: sessionCookie
         };
         // Fetch CSRF token from project page
-        const response = await fetch(`${baseUrl}/project`, {
-            headers: {
-                'Cookie': Object.entries(cookies).map(([k, v]) => `${k}=${v}`).join('; '),
-                'User-Agent': USER_AGENT
-            }
+        const initialHeaders = {
+            'Cookie': Object.entries(cookies).map(([k, v]) => `${k}=${v}`).join('; '),
+            'User-Agent': USER_AGENT
+        };
+        const bootstrapClient = new OverleafClient({ cookies, csrf: 'bootstrap', baseUrl });
+        const response = await bootstrapClient.httpRequest(`${baseUrl}/project`, {
+            headers: initialHeaders,
+            expect: 'text'
         });
         if (!response.ok) {
-            throw new Error(`Failed to fetch projects page: ${response.status} ${response.statusText}`);
-        }
-        // Capture any new cookies from response
-        const setCookieHeaders = response.headers.getSetCookie?.() || [];
-        for (const setCookie of setCookieHeaders) {
-            const match = setCookie.match(/^([^=]+)=([^;]+)/);
-            if (match) {
-                cookies[match[1]] = match[2];
-            }
+            throw new Error(`Failed to fetch projects page: ${response.status}`);
         }
-        const html = await response.text();
+        bootstrapClient.applySetCookieHeaders(response.headers['set-cookie']);
+        const html = response.body;
         const $ = cheerio.load(html);
         // Try multiple methods to find CSRF token (based on PR #66, #82)
         let csrf;
@@ -90,30 +88,13 @@ export class OverleafClient {
         if (!csrf) {
             throw new Error('Could not find CSRF token. Session may have expired.');
         }
-        return new OverleafClient({ cookies, csrf, baseUrl });
+        // Update cookies if the bootstrap request added anything
+        const updatedCookies = bootstrapClient.cookies;
+        return new OverleafClient({ cookies: updatedCookies, csrf, baseUrl });
     }
     getCookieHeader() {
         return Object.entries(this.cookies).map(([k, v]) => `${k}=${v}`).join('; ');
     }
-    applySetCookieHeaders(headers) {
-        const setCookieHeaders = headers.getSetCookie?.() || [];
-        for (const setCookie of setCookieHeaders) {
-            const match = setCookie.match(/^([^=]+)=([^;]+)/);
-            if (match) {
-                this.cookies[match[1]] = match[2];
-            }
-        }
-    }
-    async fetchWithTimeout(url, init, timeoutMs) {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), timeoutMs);
-        try {
-            return await fetch(url, { ...init, signal: controller.signal });
-        }
-        finally {
-            clearTimeout(timeout);
-        }
-    }
     getHeaders(includeContentType = false) {
         const headers = {
             'Cookie': this.getCookieHeader(),
@@ -125,17 +106,110 @@ export class OverleafClient {
         }
         return headers;
     }
+    normalizeHeaders(headers) {
+        const normalized = {};
+        if (!headers)
+            return normalized;
+        for (const [key, value] of Object.entries(headers)) {
+            if (typeof value === 'string') {
+                normalized[key] = value;
+            }
+        }
+        return normalized;
+    }
+    applySetCookieHeaders(setCookie) {
+        if (!setCookie)
+            return;
+        for (const setCookieHeader of setCookie) {
+            const match = setCookieHeader.match(/^([^=]+)=([^;]+)/);
+            if (match) {
+                this.cookies[match[1]] = match[2];
+            }
+        }
+    }
+    async httpRequest(url, options = {}) {
+        const method = options.method || 'GET';
+        const timeoutMs = options.timeoutMs ?? 10000;
+        const maxRedirects = options.maxRedirects ?? 5;
+        const expect = options.expect ?? 'text';
+        // Normalize FormData bodies into a multipart Buffer + headers using Node's
+        // built-in Web Fetch primitives. Keeps every code path on httpRequest
+        // (no fetch() reintroduction) while properly serializing multipart uploads.
+        let bodyBuffer;
+        let extraHeaders = {};
+        if (options.body instanceof FormData) {
+            const req = new Request('http://x/', { method: 'POST', body: options.body });
+            const arrayBuf = await req.arrayBuffer();
+            bodyBuffer = Buffer.from(arrayBuf);
+            const ct = req.headers.get('content-type');
+            if (ct)
+                extraHeaders['Content-Type'] = ct;
+            extraHeaders['Content-Length'] = String(bodyBuffer.length);
+        }
+        else if (options.body !== undefined) {
+            bodyBuffer = options.body;
+        }
+        const doRequest = (reqUrl, redirectsLeft) => {
+            return new Promise((resolve, reject) => {
+                const parsedUrl = new URL(reqUrl);
+                const transport = parsedUrl.protocol === 'https:' ? https : http;
+                const headers = this.normalizeHeaders({ ...extraHeaders, ...options.headers });
+                const req = transport.request(reqUrl, { method, headers }, (res) => {
+                    const status = res.statusCode || 0;
+                    const resHeaders = res.headers;
+                    if (status >= 300 && status < 400 && res.headers.location && redirectsLeft > 0) {
+                        const redirectUrl = new URL(res.headers.location, reqUrl).toString();
+                        res.resume();
+                        doRequest(redirectUrl, redirectsLeft - 1).then(resolve, reject);
+                        return;
+                    }
+                    const chunks = [];
+                    res.on('data', (chunk) => chunks.push(chunk));
+                    res.on('end', () => {
+                        const buffer = Buffer.concat(chunks);
+                        let body = buffer;
+                        if (expect === 'text') {
+                            body = buffer.toString('utf-8');
+                        }
+                        else if (expect === 'json') {
+                            try {
+                                body = JSON.parse(buffer.toString('utf-8'));
+                            }
+                            catch (e) {
+                                return reject(new Error(`Failed to parse JSON response from ${reqUrl}`));
+                            }
+                        }
+                        resolve({ status, ok: status >= 200 && status < 300, headers: resHeaders, body });
+                    });
+                    res.on('error', reject);
+                });
+                req.on('error', reject);
+                if (timeoutMs) {
+                    req.setTimeout(timeoutMs, () => {
+                        req.destroy(new Error(`Request timeout after ${timeoutMs}ms`));
+                    });
+                }
+                if (bodyBuffer !== undefined) {
+                    req.write(bodyBuffer);
+                }
+                req.end();
+            });
+        };
+        return doRequest(url, maxRedirects);
+    }
     /**
      * Get all projects (not archived, not trashed)
      */
     async listProjects() {
-        const response = await fetch(this.projectUrl(), {
-            headers: this.getHeaders()
+        const response = await this.httpRequest(this.projectUrl(), {
+            headers: this.getHeaders(),
+            expect: 'text'
         });
         if (!response.ok) {
             throw new Error(`Failed to fetch projects: ${response.status}`);
         }
-        const html = await response.text();
+        this.applySetCookieHeaders(response.headers['set-cookie']);
+        const html = response.body;
         const $ = cheerio.load(html);
         // Try new Overleaf structure first (PR #82)
         let projectsData = [];
@@ -212,13 +286,15 @@ export class OverleafClient {
      * Get detailed project info including file tree
      */
     async getProjectInfo(projectId) {
-        const response = await fetch(`${this.projectUrl()}/${projectId}`, {
-            headers: this.getHeaders()
+        const response = await this.httpRequest(`${this.projectUrl()}/${projectId}`, {
+            headers: this.getHeaders(),
+            expect: 'text'
         });
         if (!response.ok) {
             throw new Error(`Failed to fetch project info: ${response.status}`);
         }
-        const html = await response.text();
+        this.applySetCookieHeaders(response.headers['set-cookie']);
+        const html = response.body;
         const $ = cheerio.load(html);
         // Look for project data in meta tags
         let projectInfo;
@@ -248,11 +324,104 @@ export class OverleafClient {
                 }
             }
         }
+        // Fallback: Overleaf no longer ships the project tree in meta tags.
+        // Use the Socket.IO joinProjectResponse payload (same source used for
+        // root folder discovery) to retrieve the full project info.
+        if (!projectInfo) {
+            const socketProject = await this.getProjectFromSocket(projectId);
+            if (socketProject) {
+                projectInfo = socketProject;
+            }
+        }
         if (!projectInfo) {
             throw new Error('Could not parse project info');
         }
         return projectInfo;
     }
+    /**
+     * Fetch the full project object via the collaboration socket.
+     * Returns the `project` field of the joinProjectResponse, which contains
+     * the rootFolder tree and other metadata that used to live in ol-project.
+     */
+    async getProjectFromSocket(projectId) {
+        let sid = null;
+        try {
+            const handshakeUrl = `${this.baseUrl}/socket.io/1/?projectId=${encodeURIComponent(projectId)}&t=${Date.now()}`;
+            const handshakeResponse = await this.httpRequest(handshakeUrl, {
+                headers: { 'Cookie': this.getCookieHeader(), 'User-Agent': USER_AGENT },
+                expect: 'text',
+                timeoutMs: 5000
+            });
+            if (!handshakeResponse.ok)
+                return null;
+            this.applySetCookieHeaders(handshakeResponse.headers['set-cookie']);
+            const handshakeBody = handshakeResponse.body.trim();
+            sid = handshakeBody.split(':')[0];
+            if (!sid)
+                return null;
+            const buildPollUrl = () => `${this.baseUrl}/socket.io/1/xhr-polling/${sid}?projectId=${encodeURIComponent(projectId)}&t=${Date.now()}`;
+            for (let attempt = 0; attempt < 6; attempt++) {
+                const pollResponse = await this.httpRequest(buildPollUrl(), {
+                    headers: { 'Cookie': this.getCookieHeader(), 'User-Agent': USER_AGENT },
+                    expect: 'text',
+                    timeoutMs: 5000
+                });
+                if (!pollResponse.ok)
+                    return null;
+                this.applySetCookieHeaders(pollResponse.headers['set-cookie']);
+                const packets = this.decodeSocketIoPayload(pollResponse.body);
+                for (const packet of packets) {
+                    if (packet.startsWith('5:::')) {
+                        try {
+                            const payload = JSON.parse(packet.slice(4));
+                            if (payload?.name === 'joinProjectResponse' && payload?.args?.[0]?.project) {
+                                return payload.args[0].project;
+                            }
+                        }
+                        catch { /* ignore */ }
+                    }
+                    if (packet.startsWith('2::')) {
+                        const heartbeatResponse = await this.httpRequest(buildPollUrl(), {
+                            method: 'POST',
+                            headers: {
+                                'Cookie': this.getCookieHeader(),
+                                'User-Agent': USER_AGENT,
+                                'Content-Type': 'text/plain;charset=UTF-8'
+                            },
+                            body: '2::',
+                            expect: 'text',
+                            timeoutMs: 5000
+                        });
+                        this.applySetCookieHeaders(heartbeatResponse.headers['set-cookie']);
+                    }
+                }
+            }
+        }
+        catch {
+            // fall through
+        }
+        finally {
+            if (sid) {
+                try {
+                    const disconnectUrl = `${this.baseUrl}/socket.io/1/xhr-polling/${sid}?projectId=${encodeURIComponent(projectId)}&t=${Date.now()}`;
+                    const disconnectResponse = await this.httpRequest(disconnectUrl, {
+                        method: 'POST',
+                        headers: {
+                            'Cookie': this.getCookieHeader(),
+                            'User-Agent': USER_AGENT,
+                            'Content-Type': 'text/plain;charset=UTF-8'
+                        },
+                        body: '0::',
+                        expect: 'text',
+                        timeoutMs: 5000
+                    });
+                    this.applySetCookieHeaders(disconnectResponse.headers['set-cookie']);
+                }
+                catch { /* ignore */ }
+            }
+        }
+        return null;
+    }
     /**
      * Download a URL as a Buffer using Node.js http/https modules.
      *
@@ -261,34 +430,15 @@ export class OverleafClient {
      * project names). See: https://github.com/aloth/olcli/issues/2
      */
     async downloadBuffer(url) {
-        const { default: https } = await import('node:https');
-        const { default: http } = await import('node:http');
-        const doRequest = (reqUrl) => {
-            return new Promise((resolve, reject) => {
-                const parsedUrl = new URL(reqUrl);
-                const transport = parsedUrl.protocol === 'https:' ? https : http;
-                const req = transport.get(reqUrl, {
-                    headers: this.getHeaders(),
-                }, (res) => {
-                    // Follow redirects
-                    if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-                        const redirectUrl = new URL(res.headers.location, reqUrl).toString();
-                        doRequest(redirectUrl).then(resolve, reject);
-                        return;
-                    }
-                    if (res.statusCode && res.statusCode >= 400) {
-                        reject(new Error(`Download failed: ${res.statusCode}`));
-                        return;
-                    }
-                    const chunks = [];
-                    res.on('data', (chunk) => chunks.push(chunk));
-                    res.on('end', () => resolve(Buffer.concat(chunks)));
-                    res.on('error', reject);
-                });
-                req.on('error', reject);
-            });
-        };
-        return doRequest(url);
+        const response = await this.httpRequest(url, {
+            headers: this.getHeaders(),
+            expect: 'buffer'
+        });
+        if (!response.ok) {
+            throw new Error(`Download failed: ${response.status}`);
+        }
+        this.applySetCookieHeaders(response.headers['set-cookie']);
+        return response.body;
     }
     /**
      * Download project as zip
@@ -303,7 +453,7 @@ export class OverleafClient {
      * Compile project and get PDF
      */
     async compileProject(projectId) {
-        const response = await fetch(this.compileUrl(projectId), {
+        const response = await this.httpRequest(this.compileUrl(projectId), {
             method: 'POST',
             headers: this.getHeaders(true),
             body: JSON.stringify({
@@ -311,12 +461,14 @@ export class OverleafClient {
                 draft: false,
                 check: 'silent',
                 incrementalCompilesEnabled: true
-            })
+            }),
+            expect: 'json'
         });
         if (!response.ok) {
             throw new Error(`Failed to compile project: ${response.status}`);
         }
-        const data = await response.json();
+        this.applySetCookieHeaders(response.headers['set-cookie']);
+        const data = response.body;
         if (data.status !== 'success') {
             throw new Error(`Compilation failed: ${data.status}`);
         }
@@ -340,13 +492,14 @@ export class OverleafClient {
      * Create a folder in a project
      */
     async createFolder(projectId, parentFolderId, name) {
-        const response = await fetch(this.folderUrl(projectId), {
+        const response = await this.httpRequest(this.folderUrl(projectId), {
             method: 'POST',
             headers: this.getHeaders(true),
             body: JSON.stringify({
                 parent_folder_id: parentFolderId,
                 name
-            })
+            }),
+            expect: 'json'
         });
         if (response.status === 400) {
             // Folder already exists
@@ -355,7 +508,8 @@ export class OverleafClient {
         if (!response.ok) {
             throw new Error(`Failed to create folder: ${response.status}`);
         }
-        const data = await response.json();
+        this.applySetCookieHeaders(response.headers['set-cookie']);
+        const data = response.body;
         return data._id;
     }
     /**
@@ -454,16 +608,18 @@ export class OverleafClient {
         let sid = null;
         try {
             const handshakeUrl = `${this.baseUrl}/socket.io/1/?projectId=${encodeURIComponent(projectId)}&t=${Date.now()}`;
-            const handshakeResponse = await this.fetchWithTimeout(handshakeUrl, {
+            const handshakeResponse = await this.httpRequest(handshakeUrl, {
                 headers: {
                     'Cookie': this.getCookieHeader(),
                     'User-Agent': USER_AGENT
-                }
-            }, 5000);
+                },
+                expect: 'text',
+                timeoutMs: 5000
+            });
             if (!handshakeResponse.ok)
                 return null;
-            this.applySetCookieHeaders(handshakeResponse.headers);
-            const handshakeBody = (await handshakeResponse.text()).trim();
+            this.applySetCookieHeaders(handshakeResponse.headers['set-cookie']);
+            const handshakeBody = handshakeResponse.body.trim();
             sid = handshakeBody.split(':')[0];
             if (!sid)
                 return null;
@@ -471,16 +627,18 @@ export class OverleafClient {
             let discoveredRootFolderId = null;
             // poll a few frames, first is usually connect ack, next includes joinProjectResponse
             for (let attempt = 0; attempt < 3; attempt++) {
-                const pollResponse = await this.fetchWithTimeout(buildPollUrl(), {
+                const pollResponse = await this.httpRequest(buildPollUrl(), {
                     headers: {
                         'Cookie': this.getCookieHeader(),
                         'User-Agent': USER_AGENT
-                    }
-                }, 5000);
+                    },
+                    expect: 'text',
+                    timeoutMs: 5000
+                });
                 if (!pollResponse.ok)
                     return null;
-                this.applySetCookieHeaders(pollResponse.headers);
-                const payload = await pollResponse.text();
+                this.applySetCookieHeaders(pollResponse.headers['set-cookie']);
+                const payload = pollResponse.body;
                 const packets = this.decodeSocketIoPayload(payload);
                 for (const packet of packets) {
                     const rootFolderId = this.extractRootFolderIdFromSocketPacket(packet);
@@ -490,16 +648,18 @@ export class OverleafClient {
                     }
                     if (packet.startsWith('2::')) {
                         //reply to heartbeat to keep polling transport alive
-                        const heartbeatResponse = await this.fetchWithTimeout(buildPollUrl(), {
+                        const heartbeatResponse = await this.httpRequest(buildPollUrl(), {
                             method: 'POST',
                             headers: {
                                 'Cookie': this.getCookieHeader(),
                                 'User-Agent': USER_AGENT,
                                 'Content-Type': 'text/plain;charset=UTF-8'
                             },
-                            body: '2::'
-                        }, 5000);
-                        this.applySetCookieHeaders(heartbeatResponse.headers);
+                            body: '2::',
+                            expect: 'text',
+                            timeoutMs: 5000
+                        });
+                        this.applySetCookieHeaders(heartbeatResponse.headers['set-cookie']);
                     }
                 }
                 if (discoveredRootFolderId) {
@@ -514,16 +674,18 @@ export class OverleafClient {
             if (sid) {
                 try {
                     const disconnectUrl = `${this.baseUrl}/socket.io/1/xhr-polling/${sid}?projectId=${encodeURIComponent(projectId)}&t=${Date.now()}`;
-                    const disconnectResponse = await this.fetchWithTimeout(disconnectUrl, {
+                    const disconnectResponse = await this.httpRequest(disconnectUrl, {
                         method: 'POST',
                         headers: {
                             'Cookie': this.getCookieHeader(),
                             'User-Agent': USER_AGENT,
                             'Content-Type': 'text/plain;charset=UTF-8'
                         },
-                        body: '0::'
-                    }, 5000);
-                    this.applySetCookieHeaders(disconnectResponse.headers);
+                        body: '0::',
+                        expect: 'text',
+                        timeoutMs: 5000
+                    });
+                    this.applySetCookieHeaders(disconnectResponse.headers['set-cookie']);
                 }
                 catch {
                     // Ignore cleanup failures.
@@ -540,47 +702,53 @@ export class OverleafClient {
         let sid = null;
         try {
             const handshakeUrl = `${this.baseUrl}/socket.io/1/?projectId=${encodeURIComponent(projectId)}&t=${Date.now()}`;
-            const handshakeResponse = await this.fetchWithTimeout(handshakeUrl, {
+            const handshakeResponse = await this.httpRequest(handshakeUrl, {
                 headers: {
                     'Cookie': this.getCookieHeader(),
                     'User-Agent': USER_AGENT
-                }
-            }, 5000);
+                },
+                expect: 'text',
+                timeoutMs: 5000
+            });
             if (!handshakeResponse.ok)
                 return null;
-            this.applySetCookieHeaders(handshakeResponse.headers);
-            const handshakeBody = (await handshakeResponse.text()).trim();
+            this.applySetCookieHeaders(handshakeResponse.headers['set-cookie']);
+            const handshakeBody = handshakeResponse.body.trim();
             sid = handshakeBody.split(':')[0];
             if (!sid)
                 return null;
             const buildPollUrl = () => `${this.baseUrl}/socket.io/1/xhr-polling/${sid}?projectId=${encodeURIComponent(projectId)}&t=${Date.now()}`;
             for (let attempt = 0; attempt < 3; attempt++) {
-                const pollResponse = await this.fetchWithTimeout(buildPollUrl(), {
+                const pollResponse = await this.httpRequest(buildPollUrl(), {
                     headers: {
                         'Cookie': this.getCookieHeader(),
                         'User-Agent': USER_AGENT
-                    }
-                }, 5000);
+                    },
+                    expect: 'text',
+                    timeoutMs: 5000
+                });
                 if (!pollResponse.ok)
                     return null;
-                this.applySetCookieHeaders(pollResponse.headers);
-                const payload = await pollResponse.text();
+                this.applySetCookieHeaders(pollResponse.headers['set-cookie']);
+                const payload = pollResponse.body;
                 const packets = this.decodeSocketIoPayload(payload);
                 for (const packet of packets) {
                     const folderTree = this.extractFolderTreeFromSocketPacket(packet);
                     if (folderTree)
                         return folderTree;
                     if (packet.startsWith('2::')) {
-                        const heartbeatResponse = await this.fetchWithTimeout(buildPollUrl(), {
+                        const heartbeatResponse = await this.httpRequest(buildPollUrl(), {
                             method: 'POST',
                             headers: {
                                 'Cookie': this.getCookieHeader(),
                                 'User-Agent': USER_AGENT,
                                 'Content-Type': 'text/plain;charset=UTF-8'
                             },
-                            body: '2::'
-                        }, 5000);
-                        this.applySetCookieHeaders(heartbeatResponse.headers);
+                            body: '2::',
+                            expect: 'text',
+                            timeoutMs: 5000
+                        });
+                        this.applySetCookieHeaders(heartbeatResponse.headers['set-cookie']);
                     }
                 }
             }
@@ -592,15 +760,17 @@ export class OverleafClient {
             if (sid) {
                 try {
                     const disconnectUrl = `${this.baseUrl}/socket.io/1/xhr-polling/${sid}?projectId=${encodeURIComponent(projectId)}&t=${Date.now()}`;
-                    await this.fetchWithTimeout(disconnectUrl, {
+                    await this.httpRequest(disconnectUrl, {
                         method: 'POST',
                         headers: {
                             'Cookie': this.getCookieHeader(),
                             'User-Agent': USER_AGENT,
                             'Content-Type': 'text/plain;charset=UTF-8'
                         },
-                        body: '0::'
-                    }, 5000);
+                        body: '0::',
+                        expect: 'text',
+                        timeoutMs: 5000
+                    });
                 }
                 catch {
                     // Ignore cleanup failures.
@@ -704,16 +874,21 @@ export class OverleafClient {
                 formData.append('name', testFileName);
                 formData.append('type', 'text/plain');
                 formData.append('qqfile', new Blob(['probe']), testFileName);
-                const response = await fetch(`${this.uploadUrl(projectId)}?folder_id=${folderId}`, {
+                const response = await this.httpRequest(`${this.uploadUrl(projectId)}?folder_id=${folderId}`, {
                     method: 'POST',
                     headers: {
                         'Cookie': this.getCookieHeader(),
                         'User-Agent': USER_AGENT,
                         'X-Csrf-Token': this.csrf
                     },
-                    body: formData
+                    body: formData,
+                    expect: 'json'
                 });
-                const data = await response.json();
+                if (!response.ok) {
+                    continue;
+                }
+                this.applySetCookieHeaders(response.headers['set-cookie']);
+                const data = response.body;
                 if (data.success !== false && data.entity_id) {
                     // Success! Delete the probe file and return this folder ID
                     try {
@@ -771,17 +946,18 @@ export class OverleafClient {
             formData.append('name', baseName);
             formData.append('type', mimeType);
             formData.append('qqfile', new Blob([content]), baseName);
-            const response = await fetch(`${this.uploadUrl(projectId)}?folder_id=${encodeURIComponent(fid)}`, {
+            const response = await this.httpRequest(`${this.uploadUrl(projectId)}?folder_id=${encodeURIComponent(fid)}`, {
                 method: 'POST',
                 headers: {
                     'Cookie': this.getCookieHeader(),
                     'User-Agent': USER_AGENT,
                     'X-Csrf-Token': this.csrf
                 },
-                body: formData
+                body: formData,
+                expect: 'text'
             });
             if (!response.ok) {
-                const text = await response.text();
+                const text = response.body;
                 // Overleaf returns folder_not_found as HTTP 422 JSON.
                 // Parse the body first so caller can trigger folder probing fallback.
                 try {
@@ -795,7 +971,8 @@ export class OverleafClient {
                 }
                 return { success: false, error: `${response.status} - ${text}` };
             }
-            const data = await response.json();
+            this.applySetCookieHeaders(response.headers['set-cookie']);
+            const data = JSON.parse(response.body);
             if (data.success === false && data.error === 'folder_not_found') {
                 return { success: false, error: 'folder_not_found' };
             }
@@ -837,25 +1014,29 @@ export class OverleafClient {
      */
     async deleteEntity(projectId, entityId, entityType) {
         const url = this.deleteUrl(projectId, entityType, entityId);
-        const response = await fetch(url, {
+        const response = await this.httpRequest(url, {
             method: 'DELETE',
-            headers: this.getHeaders()
+            headers: this.getHeaders(),
+            expect: 'text'
         });
         if (!response.ok) {
             throw new Error(`Failed to delete entity: ${response.status}`);
         }
+        this.applySetCookieHeaders(response.headers['set-cookie']);
     }
     /**
      * Get list of entities (files/docs) with paths
      */
     async getEntities(projectId) {
-        const response = await fetch(`${this.baseUrl}/project/${projectId}/entities`, {
-            headers: this.getHeaders()
+        const response = await this.httpRequest(`${this.baseUrl}/project/${projectId}/entities`, {
+            headers: this.getHeaders(),
+            expect: 'json'
         });
         if (!response.ok) {
             throw new Error(`Failed to get entities: ${response.status}`);
         }
-        const data = await response.json();
+        this.applySetCookieHeaders(response.headers['set-cookie']);
+        const data = response.body;
         return data.entities || [];
     }
     /**
@@ -901,35 +1082,38 @@ export class OverleafClient {
      */
     async downloadFile(projectId, fileId, fileType) {
         const endpoint = fileType === 'doc' ? 'doc' : 'file';
-        const response = await fetch(`${this.baseUrl}/project/${projectId}/${endpoint}/${fileId}`, {
-            headers: this.getHeaders()
+        const response = await this.httpRequest(`${this.baseUrl}/project/${projectId}/${endpoint}/${fileId}`, {
+            headers: this.getHeaders(),
+            expect: fileType === 'doc' ? 'json' : 'buffer'
         });
         if (!response.ok) {
             throw new Error(`Failed to download file: ${response.status}`);
         }
+        this.applySetCookieHeaders(response.headers['set-cookie']);
         if (fileType === 'doc') {
             // Docs return JSON with lines array
-            const data = await response.json();
+            const data = response.body;
             const content = (data.lines || []).join('\n');
             return Buffer.from(content, 'utf-8');
         }
         else {
-            const arrayBuffer = await response.arrayBuffer();
-            return Buffer.from(arrayBuffer);
+            return response.body;
         }
     }
     /**
      * Rename a file, doc, or folder
      */
     async renameEntity(projectId, entityId, entityType, newName) {
-        const response = await fetch(`${this.baseUrl}/project/${projectId}/${entityType}/${entityId}/rename`, {
+        const response = await this.httpRequest(`${this.baseUrl}/project/${projectId}/${entityType}/${entityId}/rename`, {
             method: 'POST',
             headers: this.getHeaders(true),
-            body: JSON.stringify({ name: newName })
+            body: JSON.stringify({ name: newName }),
+            expect: 'text'
         });
         if (!response.ok) {
             throw new Error(`Failed to rename entity: ${response.status}`);
         }
+        this.applySetCookieHeaders(response.headers['set-cookie']);
     }
     /**
      * Delete a file by path
@@ -988,7 +1172,7 @@ export class OverleafClient {
      * Compile project and get all output files
      */
     async compileWithOutputs(projectId) {
-        const response = await fetch(this.compileUrl(projectId), {
+        const response = await this.httpRequest(this.compileUrl(projectId), {
             method: 'POST',
             headers: this.getHeaders(true),
             body: JSON.stringify({
@@ -996,12 +1180,14 @@ export class OverleafClient {
                 draft: false,
                 check: 'silent',
                 incrementalCompilesEnabled: true
-            })
+            }),
+            expect: 'json'
         });
         if (!response.ok) {
             throw new Error(`Failed to compile project: ${response.status}`);
         }
-        const data = await response.json();
+        this.applySetCookieHeaders(response.headers['set-cookie']);
+        const data = response.body;
         const pdfFile = data.outputFiles?.find((f) => f.type === 'pdf');
         return {
             status: data.status,