weaver-work-cli 0.1.0

package/dist/internal/e10/auth/crypto.js

@@ -0,0 +1,126 @@
+import { createCipheriv, createDecipheriv, randomBytes } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { Entry as KeyringEntry } from '@napi-rs/keyring';
+import { writeWithRetry } from '../../../core/write-with-retry.js';
+import { getE10AuthRoot } from './paths.js';
+const ALGORITHM = 'aes-256-gcm';
+const IV_LENGTH = 12;
+const TAG_LENGTH = 16;
+const KEYCHAIN_SERVICE = 'weaver-work-cli';
+const LEGACY_KEYCHAIN_SERVICE = 'e10-cli';
+const KEYCHAIN_ACCOUNT = 'auth-key';
+let encKey = null;
+function getKeyFilePath() {
+    return resolve(getE10AuthRoot(), '.key');
+}
+function getLegacyKeyFilePath() {
+    return resolve(homedir(), '.e10-cli', '.key');
+}
+function readKeychainKey(service) {
+    try {
+        const entry = new KeyringEntry(service, KEYCHAIN_ACCOUNT);
+        const stored = entry.getPassword();
+        if (stored && /^[A-Za-z0-9+/=]{40,}$/.test(stored)) {
+            const key = Buffer.from(stored, 'base64');
+            if (key.length === 32)
+                return key;
+        }
+    }
+    catch {
+        // Keychain may be unavailable in headless environments.
+    }
+    return null;
+}
+function readKeyFile(filePath) {
+    if (!existsSync(filePath))
+        return null;
+    try {
+        const key = Buffer.from(readFileSync(filePath, 'utf-8').trim(), 'base64');
+        return key.length === 32 ? key : null;
+    }
+    catch {
+        return null;
+    }
+}
+function getEncKey() {
+    if (encKey)
+        return encKey;
+    const storedKey = readKeychainKey(KEYCHAIN_SERVICE);
+    if (storedKey) {
+        encKey = storedKey;
+        return encKey;
+    }
+    try {
+        const fresh = randomBytes(32);
+        const entry = new KeyringEntry(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
+        entry.setPassword(fresh.toString('base64'));
+        encKey = fresh;
+        return encKey;
+    }
+    catch {
+        // Keychain may be unavailable in headless environments; fall back to a 0600 file.
+    }
+    const keyFile = getKeyFilePath();
+    const fileKey = readKeyFile(keyFile);
+    if (fileKey) {
+        encKey = fileKey;
+        return encKey;
+    }
+    encKey = randomBytes(32);
+    mkdirSync(getE10AuthRoot(), { recursive: true });
+    writeWithRetry(keyFile, encKey.toString('base64'), { mode: 0o600 });
+    return encKey;
+}
+function getDecryptKeys() {
+    const keys = [getEncKey()];
+    const legacyKey = readKeychainKey(LEGACY_KEYCHAIN_SERVICE) || readKeyFile(getLegacyKeyFilePath());
+    if (legacyKey && !keys.some((key) => key.equals(legacyKey)))
+        keys.push(legacyKey);
+    return keys;
+}
+export function encryptAuthData(plaintext) {
+    const iv = randomBytes(IV_LENGTH);
+    const cipher = createCipheriv(ALGORITHM, getEncKey(), iv, { authTagLength: TAG_LENGTH });
+    const encrypted = Buffer.concat([cipher.update(plaintext, 'utf-8'), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    const combined = Buffer.concat([iv, encrypted, tag]);
+    return { enc: true, v: 1, data: combined.toString('base64') };
+}
+export function decryptAuthData(wrapper) {
+    const combined = Buffer.from(wrapper.data, 'base64');
+    if (combined.length < IV_LENGTH + TAG_LENGTH + 1)
+        return null;
+    const iv = combined.subarray(0, IV_LENGTH);
+    const tag = combined.subarray(combined.length - TAG_LENGTH);
+    const encrypted = combined.subarray(IV_LENGTH, combined.length - TAG_LENGTH);
+    for (const key of getDecryptKeys()) {
+        try {
+            const decipher = createDecipheriv(ALGORITHM, key, iv, { authTagLength: TAG_LENGTH });
+            decipher.setAuthTag(tag);
+            return Buffer.concat([decipher.update(encrypted), decipher.final()]).toString('utf-8');
+        }
+        catch {
+            // Try the next known key.
+        }
+    }
+    return null;
+}
+export function parseAuthFile(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed.enc === true && typeof parsed.data === 'string') {
+            const decrypted = decryptAuthData(parsed);
+            if (!decrypted)
+                return null;
+            return JSON.parse(decrypted);
+        }
+        if (parsed.cookies && parsed.userId)
+            return parsed;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/internal/e10/auth/paths.js

@@ -0,0 +1,12 @@
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+export function getE10AuthRoot() {
+    const override = process.env.WEAVER_WORK_CLI_AUTH_ROOT?.trim();
+    return override ? resolve(override) : resolve(homedir(), '.weaver-work-cli', 'e10');
+}
+export function getE10ProfilesRoot() {
+    return resolve(getE10AuthRoot(), 'profiles');
+}
+export function getE10ActiveProfilePath() {
+    return resolve(getE10AuthRoot(), 'profile');
+}

package/dist/internal/e10/auth/session.js

@@ -0,0 +1,449 @@
+import { constants, createDecipheriv, createHash, publicEncrypt } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { CliError, ExitCode } from '../../../core/errors.js';
+import { writeWithRetry } from '../../../core/write-with-retry.js';
+import { encryptAuthData, parseAuthFile } from './crypto.js';
+import { getE10ActiveProfilePath, getE10ProfilesRoot } from './paths.js';
+const RSA_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCEOk/WyyJKdAHIfMODFnKg7MBoraFBnL3F18hhLx5n01J5g4hCkmpc5+KQFKIQIA/QWk9m7QBzI/OV9ZDFk54LaWm3xP8C+P1TPp7UVGz3iNDLdvgSxuGEYPmML3NaqkbVlvW7/NlNA3ED4Kao7rR5GUYSdFfbaBoxBFae638hzQIDAQAB
+-----END PUBLIC KEY-----`;
+const AES_SEED = 'yoJXYSzZhAOpbEFJklGtqd74X2ChTKOL';
+function sha1(data) {
+    return createHash('sha1').update(data).digest();
+}
+function getAesKey() {
+    const h = sha1(sha1(Buffer.from(AES_SEED))).toString('hex').slice(0, 32);
+    return Buffer.from(h, 'hex');
+}
+function decryptAES(key, encryptedHex) {
+    const encrypted = Buffer.from(encryptedHex, 'hex');
+    const decipher = createDecipheriv('aes-128-ecb', key, null);
+    decipher.setAutoPadding(true);
+    return Buffer.concat([decipher.update(encrypted), decipher.final()]).toString('utf-8');
+}
+async function fetchPublicKey(baseUrl, passportUrl) {
+    try {
+        const url = `${passportUrl}/papi/passport/info/getUrlInfo?type=login&service=${encodeURIComponent(baseUrl)}`;
+        const resp = await fetch(url, {
+            headers: {
+                accept: 'application/json',
+                langtype: 'zh_CN',
+                'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+            },
+        });
+        if (resp.status !== 200)
+            return null;
+        const data = await resp.json();
+        if (data.code !== 200 || !data.data?.publicKey)
+            return null;
+        const decrypted = decryptAES(getAesKey(), data.data.publicKey);
+        return '-----BEGIN PUBLIC KEY-----\n' + decrypted + '\n-----END PUBLIC KEY-----';
+    }
+    catch {
+        return null;
+    }
+}
+export function getActiveProfile() {
+    const activeProfileFile = getE10ActiveProfilePath();
+    try {
+        if (existsSync(activeProfileFile)) {
+            const name = readFileSync(activeProfileFile, 'utf-8').trim();
+            if (name)
+                return name;
+        }
+    }
+    catch {
+        // Fall through to default.
+    }
+    return 'default';
+}
+export function setActiveProfile(name) {
+    mkdirSync(getE10ProfilesRoot(), { recursive: true });
+    mkdirSync(resolve(getE10ProfilesRoot(), name), { recursive: true });
+    writeWithRetry(getE10ActiveProfilePath(), name, 'utf-8');
+}
+export function listProfiles() {
+    try {
+        if (!existsSync(getE10ProfilesRoot()))
+            return [];
+        return readdirSync(getE10ProfilesRoot(), { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+}
+export function getProfileDir(name) {
+    return resolve(getE10ProfilesRoot(), name);
+}
+export function getProfileAuthPath(name) {
+    return resolve(getProfileDir(name), 'auth');
+}
+export function getProfileConfigPath(name) {
+    return resolve(getProfileDir(name), 'config.json');
+}
+export function getActiveConfigPath() {
+    return getProfileConfigPath(getActiveProfile());
+}
+export function profileNameFromUrl(baseUrl) {
+    try {
+        const host = new URL(baseUrl).hostname;
+        const parts = host.split('.');
+        return parts.length >= 2 ? parts[parts.length - 2] : host;
+    }
+    catch {
+        return 'default';
+    }
+}
+export function readProfileConfig(profile = getActiveProfile()) {
+    const configPath = getProfileConfigPath(profile);
+    if (existsSync(configPath)) {
+        try {
+            return JSON.parse(readFileSync(configPath, 'utf-8'));
+        }
+        catch {
+            return {};
+        }
+    }
+    return {};
+}
+export function saveProfileConfig(baseUrl, passportUrl, profile = getActiveProfile(), tenantKey) {
+    const configPath = getProfileConfigPath(profile);
+    mkdirSync(dirname(configPath), { recursive: true });
+    writeWithRetry(configPath, JSON.stringify({ baseUrl, passportUrl, tenantKey }, null, 2) + '\n', { mode: 0o600 });
+}
+export function saveAuthFile(data, profile = getActiveProfile()) {
+    const authPath = getProfileAuthPath(profile);
+    mkdirSync(dirname(authPath), { recursive: true });
+    writeWithRetry(authPath, JSON.stringify(encryptAuthData(JSON.stringify(data))), { mode: 0o600 });
+    return authPath;
+}
+export function clearProfileAuthFile(profile = getActiveProfile()) {
+    const authFile = getProfileAuthPath(profile);
+    if (!existsSync(authFile))
+        return { profile, authFile, cleared: false };
+    unlinkSync(authFile);
+    return { profile, authFile, cleared: true };
+}
+export function findAuthFile(startDir = process.cwd(), options = {}) {
+    if (options.auth)
+        return options.auth;
+    if (options.profile) {
+        const profileAuth = getProfileAuthPath(options.profile);
+        if (existsSync(profileAuth))
+            return profileAuth;
+    }
+    const envAuth = process.env.E10_AUTH_PATH;
+    if (envAuth && existsSync(envAuth))
+        return envAuth;
+    const activeProfileAuth = getProfileAuthPath(getActiveProfile());
+    if (existsSync(activeProfileAuth))
+        return activeProfileAuth;
+    return null;
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+export function readTeamsCheckUserInfo(resp, data) {
+    const root = asRecord(data);
+    const nested = asRecord(root.data);
+    const currentUser = asRecord(root.currentUser || nested.currentUser);
+    const currentTenant = asRecord(root.currentTenant || nested.currentTenant);
+    const department = asRecord(currentUser.department);
+    const position = asRecord(currentUser.position);
+    const userId = resp.headers.get('employeeId')
+        || currentUser.employeeId
+        || currentUser.id
+        || nested.employeeId
+        || root.employeeId
+        || '';
+    const tenantKey = currentUser.tenantKey
+        || currentTenant.tenantKey
+        || nested.tenantKey
+        || nested.tenantkey
+        || root.tenantKey
+        || root.tenantkey
+        || '';
+    return {
+        userId: String(userId || ''),
+        tenantKey: String(tenantKey || ''),
+        tenantName: String(currentTenant.tenantName || currentTenant.name || ''),
+        department: String(department.name || ''),
+        subcompany: String(root.subCompanyName || nested.subCompanyName || ''),
+        position: String(position.name || ''),
+    };
+}
+export function buildE10CookieHeader(rawCookie, eteamsId, agentType = '') {
+    let cookie = rawCookie || '';
+    if (cookie) {
+        if (/ETEAMSID=/.test(cookie)) {
+            cookie = cookie.replace(/ETEAMSID=[^;]+/, `ETEAMSID=${eteamsId}`);
+        }
+        else if (eteamsId) {
+            cookie += `; ETEAMSID=${eteamsId}`;
+        }
+    }
+    else if (eteamsId) {
+        cookie = `ETEAMSID=${eteamsId}`;
+    }
+    if (agentType && !/agentType=/.test(cookie)) {
+        cookie = cookie ? `${cookie}; agentType=${agentType}` : `agentType=${agentType}`;
+    }
+    if (!/isAgent=/.test(cookie)) {
+        cookie = cookie ? `${cookie}; isAgent=true` : 'isAgent=true';
+    }
+    return cookie;
+}
+function splitSetCookie(value) {
+    return value.split(/,\s*(?=[^;,]+=)/).filter(Boolean);
+}
+export function extractRawSetCookie(resp) {
+    const headers = resp.headers;
+    const setCookies = headers.getSetCookie?.() || splitSetCookie(headers.get('set-cookie') || '');
+    return setCookies.map((cookie) => cookie.split(';')[0]).filter(Boolean).join('; ');
+}
+export class E10AuthSession {
+    filePath;
+    data;
+    constructor(data, filePath = null, baseUrlFallback, passportUrlFallback) {
+        this.filePath = filePath;
+        this.data = data;
+        this.data.baseUrl = this.data.baseUrl || baseUrlFallback || '';
+        this.data.passportUrl = this.data.passportUrl || passportUrlFallback || this.data.baseUrl;
+    }
+    get cookies() {
+        return this.data.cookies || {};
+    }
+    get eteamsId() {
+        return this.cookies.ETEAMSID || '';
+    }
+    get userId() {
+        return this.data.userId || '';
+    }
+    get tenantKey() {
+        return this.data.tenantKey || '';
+    }
+    get tenantName() {
+        return this.data.tenantName || '';
+    }
+    get department() {
+        return this.data.department || '';
+    }
+    get subcompany() {
+        return this.data.subcompany || '';
+    }
+    get position() {
+        return this.data.position || '';
+    }
+    get agentType() {
+        return this.data.agentType || this.data.agent_type || '';
+    }
+    get version() {
+        return this.data.version || this.data.baselineVersion || '';
+    }
+    getBaseUrl() {
+        return (this.data.baseUrl || '').replace(/\/$/, '');
+    }
+    getPassportUrl() {
+        return (this.data.passportUrl || this.getBaseUrl()).replace(/\/$/, '');
+    }
+    cookieHeader() {
+        const raw = this.cookies.raw || '';
+        return buildE10CookieHeader(raw, this.eteamsId, this.agentType);
+    }
+    uaHeader() {
+        return this.agentType ? `AgentType=${this.agentType},IsAgent=true` : 'e10-login';
+    }
+    toJSON() {
+        return {
+            userId: this.userId,
+            tenantKey: this.tenantKey,
+            tenantName: this.tenantName,
+            department: this.department,
+            subcompany: this.subcompany,
+            position: this.position,
+            agentType: this.agentType,
+            version: this.version,
+            baseUrl: this.getBaseUrl(),
+            passportUrl: this.getPassportUrl(),
+            stTicket: this.data.stTicket,
+            redirectUrl: this.data.redirectUrl,
+            cookieSavedAt: this.data.cookieSavedAt,
+            mainUrl: this.data.mainUrl,
+            hasEteamsId: Boolean(this.eteamsId),
+        };
+    }
+    static fromFile(filePath, baseUrlFallback, passportUrlFallback) {
+        try {
+            const raw = readFileSync(filePath, 'utf-8');
+            const data = parseAuthFile(raw);
+            if (!data || !data.cookies?.ETEAMSID || !data.baseUrl)
+                return null;
+            return new E10AuthSession(data, filePath, baseUrlFallback, passportUrlFallback);
+        }
+        catch {
+            return null;
+        }
+    }
+    static async fromOptions(options, startDir = process.cwd()) {
+        let baseUrl = options.baseUrl;
+        let passportUrl = options.passportUrl;
+        if (options.profile) {
+            const cfg = readProfileConfig(options.profile);
+            baseUrl ||= cfg.baseUrl;
+            passportUrl ||= cfg.passportUrl;
+        }
+        const authPath = findAuthFile(startDir, options);
+        if (!authPath)
+            return null;
+        const session = E10AuthSession.fromFile(authPath, baseUrl, passportUrl);
+        if (session)
+            await session.fetchEmployeeId();
+        return session;
+    }
+    async fetchEmployeeId() {
+        try {
+            const resp = await fetch(`${this.getBaseUrl()}/api/baseserver/layout/teamsCheck?clientType=not_xinchuang&client=WEB&domainName=${encodeURIComponent(this.getBaseUrl())}`, {
+                method: 'POST',
+                headers: {
+                    accept: 'application/json',
+                    'content-type': 'application/json',
+                    eteamsid: this.eteamsId,
+                    cookie: this.cookieHeader(),
+                    'user-agent': this.uaHeader(),
+                    origin: this.getBaseUrl(),
+                },
+            });
+            const data = await resp.json().catch(() => ({}));
+            const userInfo = readTeamsCheckUserInfo(resp, data);
+            if (userInfo.userId && userInfo.userId !== this.data.userId)
+                this.data.userId = userInfo.userId;
+            if (userInfo.tenantKey)
+                this.data.tenantKey = userInfo.tenantKey;
+            if (userInfo.tenantName)
+                this.data.tenantName = userInfo.tenantName;
+            if (userInfo.department)
+                this.data.department = userInfo.department;
+            if (userInfo.subcompany)
+                this.data.subcompany = userInfo.subcompany;
+            if (userInfo.position)
+                this.data.position = userInfo.position;
+        }
+        catch {
+            // Non-critical profile enrichment.
+        }
+    }
+    async checkValid() {
+        try {
+            const resp = await fetch(`${this.getBaseUrl()}/api/ecode/tree/list?parentId=0`, {
+                headers: {
+                    accept: 'application/json',
+                    eteamsid: this.eteamsId,
+                    cookie: this.cookieHeader(),
+                    'user-agent': this.uaHeader(),
+                },
+                redirect: 'manual',
+            });
+            return resp.status === 200;
+        }
+        catch {
+            return false;
+        }
+    }
+    async ensureValid() {
+        if (await this.checkValid())
+            return true;
+        const account = process.env.E10_ACCOUNT;
+        const password = process.env.E10_PASSWORD;
+        if (!account || !password)
+            return false;
+        await this.rsaLogin(account, password);
+        this.save();
+        return true;
+    }
+    async rsaLogin(account, password) {
+        const passport = this.getPassportUrl();
+        const base = this.getBaseUrl();
+        const pem = (await fetchPublicKey(base, passport)) || RSA_PUBLIC_KEY_PEM;
+        const enc = (value) => publicEncrypt({ key: pem, padding: constants.RSA_PKCS1_PADDING }, Buffer.from(value, 'utf-8')).toString('base64');
+        const resp = await fetch(`${passport}/papi/passport/login/pclogin`, {
+            method: 'POST',
+            headers: {
+                accept: 'application/json, text/plain, */*',
+                'content-type': 'application/json;charset=UTF-8',
+                langtype: 'zh_CN',
+                origin: passport,
+            },
+            body: JSON.stringify({
+                account: enc(account),
+                password: enc(password),
+                service: base,
+                tenantKey: 'all_teams',
+                teamsInfo: JSON.stringify({ urlSearchParams: `?service=${encodeURIComponent(base)}` }),
+                passportCusLoginDomain: passport,
+                serviceToken: '',
+                auxiliaryToken: '',
+                language: 'zh_CN',
+                onlySelfTenant: 0,
+                loginRedirectUrl: '',
+                devType: '72',
+                registerDataSource: '',
+                registerSource: '',
+                registerSourceUrl: '',
+                moduleSource: '',
+                integratedLoginId: '',
+                agreementChecked: '0',
+                needPassword: true,
+            }),
+            redirect: 'manual',
+        });
+        const result = await resp.json();
+        if (result.code !== 200 || !result.status || !result.data?.stTicket) {
+            throw new CliError(result.msg || 'E10 RSA login failed', ExitCode.AuthError);
+        }
+        const ticketResp = await fetch(`${base}/papi/baseserver/layout/checkTicket`, {
+            method: 'POST',
+            headers: {
+                accept: 'application/json',
+                'content-type': 'application/json',
+                origin: base,
+            },
+            body: JSON.stringify({ ticket: result.data.stTicket, service: base }),
+            redirect: 'manual',
+        });
+        const headers = ticketResp.headers;
+        const setCookies = headers.getSetCookie?.() || [];
+        const cookies = {};
+        for (const cookie of setCookies) {
+            const match = cookie.match(/^([^=]+)=([^;]+)/);
+            if (match)
+                cookies[match[1].trim()] = match[2];
+        }
+        const rawCookie = extractRawSetCookie(ticketResp);
+        if (rawCookie)
+            cookies.raw = rawCookie;
+        const ticketData = await ticketResp.json().catch(() => ({}));
+        const userInfo = readTeamsCheckUserInfo(ticketResp, ticketData);
+        this.data = {
+            cookies,
+            userId: userInfo.userId || account,
+            tenantKey: userInfo.tenantKey || this.tenantKey,
+            tenantName: userInfo.tenantName,
+            department: userInfo.department,
+            subcompany: userInfo.subcompany,
+            position: userInfo.position,
+            baseUrl: base,
+            passportUrl: passport,
+            stTicket: '',
+            redirectUrl: '',
+            cookieSavedAt: Date.now(),
+        };
+    }
+    save() {
+        if (!this.filePath)
+            return;
+        writeWithRetry(this.filePath, JSON.stringify(encryptAuthData(JSON.stringify(this.data))), { mode: 0o600 });
+    }
+}

package/dist/internal/e10/client.js

@@ -0,0 +1,104 @@
+export class E10ApiClient {
+    auth;
+    retries;
+    constructor(auth, retries = 3) {
+        this.auth = auth;
+        this.retries = retries;
+    }
+    getBaseUrl() {
+        return this.auth.getBaseUrl();
+    }
+    url(pathOrUrl) {
+        if (/^https?:\/\//i.test(pathOrUrl))
+            return pathOrUrl;
+        return this.getBaseUrl() + (pathOrUrl.startsWith('/') ? pathOrUrl : '/' + pathOrUrl);
+    }
+    defaultHeaders() {
+        return {
+            accept: 'application/json, text/plain, */*',
+            langtype: 'zh_CN',
+            eteamsid: this.auth.eteamsId,
+            cookie: this.auth.cookieHeader(),
+            'user-agent': this.auth.uaHeader(),
+        };
+    }
+    async get(url, extraHeaders = {}) {
+        return this.request('GET', url, undefined, extraHeaders);
+    }
+    async post(url, body, extraHeaders = {}) {
+        return this.request('POST', url, body, extraHeaders);
+    }
+    async postForm(url, formData, extraHeaders = {}) {
+        const headers = {
+            ...this.defaultHeaders(),
+            'content-type': 'application/x-www-form-urlencoded',
+            ...extraHeaders,
+        };
+        return this.requestRaw(this.url(url), { method: 'POST', headers, body: String(formData) });
+    }
+    async postMultipart(url, form, extraHeaders = {}) {
+        const headers = { ...this.defaultHeaders(), ...extraHeaders };
+        return this.requestRaw(this.url(url), { method: 'POST', headers, body: form });
+    }
+    async request(method, url, body, extraHeaders = {}) {
+        const headers = { ...this.defaultHeaders(), ...extraHeaders };
+        let fetchBody;
+        if (body !== undefined && body !== null) {
+            if (typeof body === 'object' && !(body instanceof FormData) && !(body instanceof URLSearchParams)) {
+                headers['content-type'] = 'application/json;charset=UTF-8';
+                fetchBody = JSON.stringify(body);
+            }
+            else {
+                fetchBody = body;
+            }
+        }
+        return this.requestRaw(this.url(url), { method, headers, body: fetchBody });
+    }
+    async requestRaw(url, init) {
+        let lastError = null;
+        for (let attempt = 1; attempt <= this.retries; attempt++) {
+            try {
+                const resp = await fetch(url, { ...init, redirect: 'manual' });
+                if (resp.status === 302) {
+                    const ok = await this.auth.ensureValid();
+                    if (!ok)
+                        throw new Error('E10 session expired; please login again');
+                    const headers = (init.headers || {});
+                    headers.eteamsid = this.auth.eteamsId;
+                    headers.cookie = this.auth.cookieHeader();
+                    headers['user-agent'] = this.auth.uaHeader();
+                    init.headers = headers;
+                    continue;
+                }
+                const text = await resp.text();
+                if (!text)
+                    return null;
+                try {
+                    return JSON.parse(text);
+                }
+                catch {
+                    return text;
+                }
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                if (attempt < this.retries) {
+                    const delay = Math.min(1000 * Math.pow(2, attempt - 1), 8000);
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                }
+            }
+        }
+        throw lastError || new Error('E10 API request failed');
+    }
+    static buildMultipart(fields) {
+        const boundary = `----WebKitFormBoundary${Math.random().toString(36).slice(2, 18)}`;
+        let body = '';
+        for (const [name, value] of Object.entries(fields)) {
+            body += `--${boundary}\r\n`;
+            body += `Content-Disposition: form-data; name="${name}"\r\n\r\n`;
+            body += `${value}\r\n`;
+        }
+        body += `--${boundary}--\r\n`;
+        return { body, boundary };
+    }
+}