finary-community 0.1.0

package/README.md

@@ -0,0 +1,229 @@
+# Finary Community Library
+
+Une bibliothèque non-officielle et communautaire pour s'interfacer avec l'API Finary. Elle permet de récupérer vos données de patrimoine, transactions, insights et bien plus encore de manière programmatique.
+
+## Installation
+
+```bash
+npm install finary-community
+```
+
+## Configuration & Authentification
+
+L'authentification sur Finary étant complexe (protection anti-bot), cette librairie fonctionne actuellement en utilisant une session navigateur existante.
+
+Vous devez créer un fichier `credentials.json` à la racine de votre projet.
+Vous pouvez le générer automatiquement en lançant la commande interactive :
+
+```bash
+npm run setup
+```
+
+Ou le créer manuellement :
+
+### Structure du fichier `credentials.json`
+
+```json
+{
+    "token": "JWT_TOKEN_ICI",
+    "clerkSession": "CLERK_SESSION_ID_ICI",
+    "headers": {
+        "user-agent": "Mozilla/5.0 ...",
+        "cookie": "..."
+    }
+}
+```
+
+> **Note :** Le `clerkSession` et les `headers` (cookie) sont essentiels pour permettre le rafraîchissement automatique du token.
+
+## API Reference
+
+Voici la documentation détaillée de chaque fonction disponible dans la librairie.
+
+### Types et Enums Communs
+
+Plusieurs fonctions utilisent les énumérations suivantes pour filtrer les données :
+
+*   **`FinaryPeriod`** : Période temporelle pour les graphiques et variations.
+    *   `'1d'` (24h), `'1w'` (Semaine), `'1m'` (Mois), `'ytd'` (Depuis début d'année), `'1y'` (1 an), `'all'` (Tout).
+*   **`TimeseriesType`** : Type de série temporelle.
+    *   `'sum'` (Valeur cumulée), `'all'` (Détail).
+*   **`DistributionType`** : Type de répartition.
+    *   `'account'` (Par compte).
+*   **`InvestmentDistributionType`** : Type de répartition investissement.
+    *   `'stock'` (Par action/actif).
+
+---
+
+### 1. Client Principal (`FinaryClient`)
+
+Point d'entrée de la librairie.
+
+#### `constructor(config)`
+Initialise le client.
+*   **Paramètres** :
+    *   `config` (`AuthConfig`) : Objet de configuration `{ credentialsPath: string }`.
+
+#### `getUserProfile()`
+Récupère les informations du profil utilisateur connecté.
+*   **Retourne** : `Promise<UserProfile>` (Nom, email, paramètres, etc.)
+
+#### `getOrganizations()`
+Liste les organisations (souvent appelées "familles" dans l'UI) associées à l'utilisateur. Vous aurez besoin de l'ID de l'organisation et du membre pour la plupart des autres appels.
+*   **Retourne** : `Promise<Organization[]>`
+
+---
+
+### 2. Investissements (`client.investments`)
+
+Tous les appels nécessitent généralement `organizationId` et `membershipId`.
+
+#### `getPortfolio(organizationId, membershipId, period)`
+Vue d'ensemble du portefeuille d'investissements (Actions, Crypto, Immo, etc.).
+*   **Paramètres** :
+    *   `organizationId` (`string`) : ID de l'organisation.
+    *   `membershipId` (`string`) : ID du membre.
+    *   `period` (`FinaryPeriod`, défaut: `YTD`) : Période de calcul des plus/moins-values.
+*   **Retourne** : `Promise<InvestmentPortfolio>`
+
+#### `getTimeseries(organizationId, membershipId, period, type)`
+Récupère l'historique de la valeur du portefeuille (graphique).
+*   **Paramètres** :
+    *   `period` (`FinaryPeriod`, défaut: `YTD`).
+    *   `type` (`TimeseriesType`, défaut: `SUM`).
+*   **Retourne** : `Promise<Timeseries[]>`
+
+#### `getDistribution(organizationId, membershipId, type, period)`
+Répartition des actifs.
+*   **Paramètres** :
+    *   `type` (`InvestmentDistributionType`, défaut: `STOCK`).
+*   **Retourne** : `Promise<Distribution>`
+
+#### `getDividends(organizationId, membershipId, withRealEstate)`
+Liste les dividendes perçus et à venir.
+*   **Paramètres** :
+    *   `withRealEstate` (`boolean`, défaut: `true`) : Inclure les loyers/dividendes immobiliers (SCPI).
+*   **Retourne** : `Promise<DividendsResponse>`
+
+#### `getSectorAllocation(organizationId, membershipId)`
+Répartition sectorielle du portefeuille (Technologie, Santé, Finance...).
+*   **Retourne** : `Promise<SectorAllocationResponse>`
+
+#### `getGeographicalAllocation(organizationId, membershipId)`
+Répartition géographique du portefeuille (USA, Europe, Asie...).
+*   **Retourne** : `Promise<GeographicalAllocationResponse>`
+
+#### `getFees(organizationId, membershipId)`
+Analyse des frais sur les enveloppes (PEA, CTO, AV...).
+*   **Retourne** : `Promise<FeesResponse>`
+
+#### `getAccount(organizationId, membershipId, accountId, period)`
+Détails d'un compte spécifique (ex: un PEA particulier).
+*   **Paramètres** :
+    *   `accountId` (`string`) : ID du compte.
+*   **Retourne** : `Promise<InvestmentAccount>`
+
+#### Méthodes "Account" Spécifiques
+De la même manière que pour le portefeuille global, vous pouvez appeler ces méthodes pour un compte précis :
+*   `getAccountTimeseries(orgId, memId, accountId, period, type)`
+*   `getAccountDistribution(orgId, memId, accountId, type, period)`
+*   `getAccountDividends(orgId, memId, accountId, withRealEstate)`
+*   `getAccountSectorAllocation(orgId, memId, accountId)`
+*   `getAccountGeographicalAllocation(orgId, memId, accountId)`
+*   `getAccountFees(orgId, memId, accountId)`
+
+---
+
+### 3. Épargne (`client.savings`)
+
+Concerne les livrets bancaires, fonds euros, etc.
+
+#### `getPortfolio(organizationId, membershipId, period)`
+Vue d'ensemble de l'épargne.
+*   **Retourne** : `Promise<SavingsPortfolio>`
+
+#### `getAccounts(organizationId, membershipId, period)`
+Liste tous les comptes d'épargne.
+*   **Retourne** : `Promise<SavingsAccount[]>`
+
+#### `getAccount(organizationId, membershipId, accountId, period)`
+Détails d'un compte épargne spécifique.
+*   **Retourne** : `Promise<SavingsAccount>`
+
+#### `getTransaction(organizationId, membershipId, page, perPage, query, accountId)`
+Récupère les transactions (virements, intérêts).
+*   **Paramètres** :
+    *   `page` (`number`, défaut: `1`) : Numéro de page.
+    *   `perPage` (`number`, défaut: `50`) : Nombre d'éléments par page.
+    *   `query` (`string`, optionnel) : Recherche textuelle.
+    *   `accountId` (`string`, optionnel) : Filtrer par compte spécifique.
+*   **Retourne** : `Promise<Transaction[]>`
+
+#### `getTimeseries(...)` et `getAccountTimeseries(...)`
+Historique de valeur.
+
+---
+
+### 4. Comptes Courants (`client.checkings`)
+
+#### `getPortfolio(organizationId, membershipId, period)`
+Solde total des comptes courants.
+*   **Retourne** : `Promise<CheckingPortfolio>`
+
+#### `getAccounts(organizationId, membershipId, period)`
+Liste des comptes bancaires.
+*   **Retourne** : `Promise<CheckingAccount[]>`
+
+#### `getTransactions(...)`
+Récupère les transactions bancaires. Fonctionne identiquement à celle de l'épargne.
+
+---
+
+### 5. Benchmarks (`client.benchmarks`)
+
+#### `getAvailableAssets(organizationId, membershipId, period)`
+Récupère la liste des actifs disponibles pour faire des comparaisons de performance.
+*   **Retourne** : `Promise<BenchmarkAsset[]>`
+
+## Exemple Complet
+
+```typescript
+import { FinaryClient, FinaryPeriod } from 'finary-community';
+
+const client = new FinaryClient({ credentialsPath: './credentials.json' });
+
+async function main() {
+    // 1. Setup
+    const orgs = await client.getOrganizations();
+    const orgId = orgs[0].id;
+    const memberId = orgs[0].members[0].id;
+
+    console.log(`Utilisateur : ${orgs[0].name}`);
+
+    // 2. Investissements
+    const investments = await client.investments.getPortfolio(orgId, memberId, FinaryPeriod.YTD);
+    console.log(`--- Investissements ---`);
+    console.log(`Total : ${investments.total.amount} €`);
+    console.log(`Plus-value latente : ${investments.total.unrealized_pnl} €`);
+
+    // 3. Dividendes à venir
+    const dividends = await client.investments.getDividends(orgId, memberId);
+    if(dividends.upcoming_dividends.length > 0) {
+        console.log(`--- Prochains Dividendes ---`);
+        dividends.upcoming_dividends.forEach(div => {
+            console.log(`${div.date} : ${div.amount}€ (${div.asset.name})`);
+        });
+    }
+
+    // 4. Recherche de transactions Livret A
+    const savings = await client.savings.getAccounts(orgId, memberId);
+    const livretA = savings.find(s => s.name.includes("Livret A"));
+    if (livretA) {
+        console.log(`--- Transactions Livret A ---`);
+        const txs = await client.savings.getTransactions(orgId, memberId, 1, 5, '', livretA.id);
+        txs.forEach(t => console.log(`${t.date} : ${t.amount}€ - ${t.description}`));
+    }
+}
+
+main().catch(console.error);
+```

package/dist/auth/auth-manager.d.ts

@@ -0,0 +1,12 @@
+import { AuthConfig, Credentials } from "../interfaces";
+export declare class AuthManager {
+    private token;
+    private credentialsPath;
+    private cachedCredentials;
+    constructor(config: AuthConfig);
+    private loadCredentials;
+    getToken(): Promise<string>;
+    getCredentials(): Credentials;
+    refreshToken(): Promise<string>;
+    private parseJwt;
+}

package/dist/auth/auth-manager.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthManager = void 0;
+const node_fs_1 = require("node:fs");
+class AuthManager {
+    constructor(config) {
+        this.token = null;
+        this.cachedCredentials = null;
+        this.credentialsPath = config.credentialsPath;
+    }
+    loadCredentials() {
+        if (this.cachedCredentials)
+            return this.cachedCredentials;
+        if ((0, node_fs_1.existsSync)(this.credentialsPath)) {
+            try {
+                const data = (0, node_fs_1.readFileSync)(this.credentialsPath, "utf-8");
+                this.cachedCredentials = JSON.parse(data);
+                return this.cachedCredentials;
+            }
+            catch (e) {
+                console.error(`Failed to parse credentials at ${this.credentialsPath}: ${e}`);
+            }
+        }
+        throw new Error(`credentials.json not found at ${this.credentialsPath}`);
+    }
+    async getToken() {
+        if (this.token)
+            return this.token;
+        const creds = this.loadCredentials();
+        if (creds.token) {
+            this.token = creds.token;
+            return this.token;
+        }
+        throw new Error("No token found in credentials.");
+    }
+    getCredentials() {
+        return this.loadCredentials();
+    }
+    async refreshToken() {
+        const creds = this.loadCredentials();
+        // 1. Clerk Refresh
+        if (creds.clerkSession && this.token) {
+            try {
+                const decoded = this.parseJwt(this.token);
+                const sessionId = decoded ? decoded.sid : null;
+                if (sessionId) {
+                    const clerkUrl = `https://clerk.finary.com/v1/client/sessions/${sessionId}/tokens?__clerk_api_version=2025-11-10&_clerk_js_version=5.117.0`;
+                    const cookieHeader = creds.cookieHeader || `__session=${creds.clerkSession}`;
+                    const response = await fetch(clerkUrl, {
+                        method: "POST",
+                        headers: {
+                            "Cookie": cookieHeader,
+                            "Content-Type": "application/x-www-form-urlencoded",
+                            "Origin": "https://app.finary.com",
+                            "Referer": "https://app.finary.com/",
+                            "User-Agent": creds.headers?.['user-agent'] || "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36"
+                        },
+                        body: "organization_id="
+                    });
+                    if (response.ok) {
+                        const data = (await response.json());
+                        if (data && data.jwt) {
+                            this.token = data.jwt;
+                            return this.token;
+                        }
+                    }
+                    else {
+                        console.warn(`Clerk refresh failed: ${response.status}`);
+                    }
+                }
+            }
+            catch (e) {
+                console.error(`Clerk refresh error: ${e}`);
+            }
+        }
+        // 2. Legacy Refresh
+        if (!creds.refreshUrl || !creds.headers) {
+            throw new Error("Missing info to refresh token (legacy).");
+        }
+        try {
+            const headers = { ...creds.headers };
+            // Cleanup headers manually since we can't use arbitrary types easily on headers object
+            delete headers['content-length'];
+            delete headers['host'];
+            delete headers['connection'];
+            delete headers['origin'];
+            delete headers['referer'];
+            delete headers['cookie'];
+            Object.keys(headers).forEach(key => { if (key.startsWith(':'))
+                delete headers[key]; });
+            const response = await fetch(creds.refreshUrl, {
+                method: "POST",
+                headers: headers,
+            });
+            if (!response.ok) {
+                throw new Error(`Legacy refresh failed: ${response.status}`);
+            }
+            const data = (await response.json());
+            if (data && data.jwt) {
+                this.token = data.jwt;
+                return this.token;
+            }
+            throw new Error("No JWT in refresh response");
+        }
+        catch (e) {
+            console.error(`Token Refresh Error: ${e}`);
+            throw e;
+        }
+    }
+    parseJwt(token) {
+        try {
+            return JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.AuthManager = AuthManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth-manager.js","sourceRoot":"","sources":["../../src/auth/auth-manager.ts"],"names":[],"mappings":"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","sourcesContent":["import { readFileSync, existsSync } from \"node:fs\";\r\nimport { AuthConfig, Credentials } from \"../interfaces\";\r\n\r\nexport class AuthManager {\r\n    private token: string | null = null;\r\n    private credentialsPath: string;\r\n    private cachedCredentials: Credentials | null = null;\r\n\r\n    constructor(config: AuthConfig) {\r\n        this.credentialsPath = config.credentialsPath;\r\n    }\r\n\r\n    private loadCredentials(): Credentials {\r\n        if (this.cachedCredentials) return this.cachedCredentials;\r\n\r\n        if (existsSync(this.credentialsPath)) {\r\n            try {\r\n                const data = readFileSync(this.credentialsPath, \"utf-8\");\r\n                this.cachedCredentials = JSON.parse(data) as Credentials;\r\n                return this.cachedCredentials;\r\n            } catch (e) {\r\n                console.error(`Failed to parse credentials at ${this.credentialsPath}: ${e}`);\r\n            }\r\n        }\r\n\r\n        throw new Error(`credentials.json not found at ${this.credentialsPath}`);\r\n    }\r\n\r\n    public async getToken(): Promise<string> {\r\n        if (this.token) return this.token;\r\n\r\n        const creds = this.loadCredentials();\r\n        if (creds.token) {\r\n            this.token = creds.token;\r\n            return this.token;\r\n        }\r\n\r\n        throw new Error(\"No token found in credentials.\");\r\n    }\r\n\r\n    public getCredentials(): Credentials {\r\n        return this.loadCredentials();\r\n    }\r\n\r\n    public async refreshToken(): Promise<string> {\r\n        const creds = this.loadCredentials();\r\n\r\n        // 1. Clerk Refresh\r\n        if (creds.clerkSession && this.token) {\r\n            try {\r\n                const decoded = this.parseJwt(this.token);\r\n                const sessionId = decoded ? decoded.sid : null;\r\n\r\n                if (sessionId) {\r\n                    const clerkUrl = `https://clerk.finary.com/v1/client/sessions/${sessionId}/tokens?__clerk_api_version=2025-11-10&_clerk_js_version=5.117.0`;\r\n                    const cookieHeader = creds.cookieHeader || `__session=${creds.clerkSession}`;\r\n\r\n                    const response = await fetch(clerkUrl, {\r\n                        method: \"POST\",\r\n                        headers: {\r\n                            \"Cookie\": cookieHeader,\r\n                            \"Content-Type\": \"application/x-www-form-urlencoded\",\r\n                            \"Origin\": \"https://app.finary.com\",\r\n                            \"Referer\": \"https://app.finary.com/\",\r\n                            \"User-Agent\": creds.headers?.['user-agent'] || \"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36\"\r\n                        },\r\n                        body: \"organization_id=\"\r\n                    });\r\n\r\n                    if (response.ok) {\r\n                        const data = (await response.json()) as any;\r\n                        if (data && data.jwt) {\r\n                            this.token = data.jwt;\r\n                            return this.token as string;\r\n                        }\r\n                    } else {\r\n                        console.warn(`Clerk refresh failed: ${response.status}`);\r\n                    }\r\n                }\r\n            } catch (e) {\r\n                console.error(`Clerk refresh error: ${e}`);\r\n            }\r\n        }\r\n\r\n        // 2. Legacy Refresh\r\n        if (!creds.refreshUrl || !creds.headers) {\r\n            throw new Error(\"Missing info to refresh token (legacy).\");\r\n        }\r\n\r\n        try {\r\n            const headers: Record<string, string> = { ...creds.headers };\r\n            // Cleanup headers manually since we can't use arbitrary types easily on headers object\r\n            delete headers['content-length'];\r\n            delete headers['host'];\r\n            delete headers['connection'];\r\n            delete headers['origin'];\r\n            delete headers['referer'];\r\n            delete headers['cookie'];\r\n\r\n            Object.keys(headers).forEach(key => { if (key.startsWith(':')) delete headers[key]; });\r\n\r\n            const response = await fetch(creds.refreshUrl, {\r\n                method: \"POST\",\r\n                headers: headers,\r\n            });\r\n\r\n            if (!response.ok) {\r\n                throw new Error(`Legacy refresh failed: ${response.status}`);\r\n            }\r\n\r\n            const data = (await response.json()) as any;\r\n            if (data && data.jwt) {\r\n                this.token = data.jwt;\r\n                return this.token as string;\r\n            }\r\n            throw new Error(\"No JWT in refresh response\");\r\n\r\n        } catch (e) {\r\n            console.error(`Token Refresh Error: ${e}`);\r\n            throw e;\r\n        }\r\n    }\r\n\r\n    private parseJwt(token: string): any {\r\n        try {\r\n            return JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());\r\n        } catch {\r\n            return null;\r\n        }\r\n    }\r\n}\r\n"]}

package/dist/auth/login-helper.d.ts

@@ -0,0 +1,11 @@
+export interface CreateSessionOptions {
+    headless?: boolean;
+    outputPath?: string;
+}
+export declare function createSession(options?: CreateSessionOptions): Promise<{
+    token: string;
+    refreshUrl: string;
+    headers: Record<string, string>;
+    clerkSession: string | null;
+    cookieHeader: string;
+}>;

package/dist/auth/login-helper.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSession = createSession;
+const puppeteer_1 = __importDefault(require("puppeteer"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+async function createSession(options = {}) {
+    const { headless = false, outputPath } = options;
+    console.log("------------------------------------------");
+    console.log("   Finary Setup - Browser Login");
+    console.log("------------------------------------------");
+    if (outputPath) {
+        // Ensure directory exists
+        const dir = node_path_1.default.dirname(outputPath);
+        if (!node_fs_1.default.existsSync(dir)) {
+            try {
+                node_fs_1.default.mkdirSync(dir, { recursive: true });
+            }
+            catch (e) {
+                throw new Error(`Error creating directory ${dir}: ${e.message}`);
+            }
+        }
+        console.log(`Will save to: ${outputPath}`);
+    }
+    console.log("Launching browser for authentication...");
+    let browser;
+    try {
+        browser = await puppeteer_1.default.launch({
+            headless: headless,
+            defaultViewport: null,
+            args: ['--start-maximized'] // Find browser window easier
+        });
+    }
+    catch (e) {
+        console.error("Failed to launch browser. Make sure you installed puppeteer: npm install puppeteer");
+        throw e;
+    }
+    try {
+        const page = await browser.newPage();
+        await page.setRequestInterception(false); // Ensure interception does not block unless intended
+        page.on('request', request => {
+            const url = request.url();
+            if (url.includes('clerk.finary.com')) {
+                // Optional: log or handle clerk requests
+            }
+        });
+        console.log("Navigating to Finary login page...");
+        await page.goto('https://app.finary.com/v2', { waitUntil: 'domcontentloaded' });
+        console.log("\nACTION REQUIRED: Please log in to your Finary account in the opened browser window.\n");
+        console.log("Scanning network traffic for authentication token...");
+        // Promise that resolves when the valid token is found
+        const waitForToken = new Promise((resolve) => {
+            page.on('response', response => {
+                const request = response.request();
+                const url = request.url();
+                // Filter API requests
+                if (url.includes('api.finary.com') || url.includes('clerk.finary.com')) {
+                    // We only want successful requests to ensure the token is valid
+                    if (response.status() === 200) {
+                        const headers = request.headers();
+                        const auth = headers['authorization'];
+                        if (auth && auth.startsWith('Bearer ey')) {
+                            const token = auth.replace('Bearer ', '');
+                            console.log("✅ Valid token successfully detected from successful request!");
+                            resolve({ token, headers });
+                        }
+                    }
+                }
+            });
+        });
+        const { token, headers } = await waitForToken;
+        console.log("Token detected! capturing cookies...");
+        // Capture cookies for both the main app and the clerk subdomain to ensure we get __client, __session, etc.
+        const cookies = await page.cookies('https://app.finary.com', 'https://clerk.finary.com');
+        const cookieHeader = cookies.map(c => `${c.name}=${c.value}`).join('; ');
+        const sessionCookie = cookies.find(c => c.name === '__session');
+        const clerkSession = sessionCookie ? sessionCookie.value : null;
+        if (cookieHeader) {
+            console.log("✅ Cookies captured!");
+        }
+        else {
+            console.warn("⚠️ No cookies found. Refresh verify might fail.");
+        }
+        console.log("Fetching user details...");
+        // Use the token to identify the user
+        let email = "unknown_user@example.com";
+        try {
+            const meResp = await fetch("https://api.finary.com/users/me", {
+                headers: {
+                    "Authorization": `Bearer ${token}`,
+                    "User-Agent": "Mozilla/5.0"
+                }
+            });
+            if (meResp.ok) {
+                const data = await meResp.json();
+                if (data.result && data.result.email) {
+                    email = data.result.email;
+                    console.log(`Identified as: ${email}`);
+                }
+            }
+        }
+        catch (e) {
+            console.warn("Could not fetch user email (minor issue), proceeding anyway.");
+        }
+        // Filter headers based on user request ("only these specific headers")
+        const allowedHeaderKeys = [
+            "sec-ch-ua-platform",
+            "x-client-api-version",
+            "referer",
+            "accept-language",
+            "sec-ch-ua",
+            "sec-ch-ua-mobile",
+            "user-agent",
+            "x-finary-client-id",
+            ":authority",
+            ":method",
+            ":scheme",
+            "accept",
+            "accept-encoding",
+            "origin",
+            "priority",
+            "sec-fetch-dest",
+            "sec-fetch-mode",
+            "sec-fetch-site"
+        ];
+        const filteredHeaders = {};
+        for (const key of allowedHeaderKeys) {
+            if (headers[key]) {
+                filteredHeaders[key] = headers[key];
+            }
+        }
+        const credentialsData = {
+            token: token,
+            refreshUrl: "https://clerk.finary.com/v1/client/sessions",
+            headers: filteredHeaders,
+            clerkSession: clerkSession, // Kept for backward compatibility
+            cookieHeader: cookieHeader,
+        };
+        if (outputPath) {
+            const jsonContent = JSON.stringify(credentialsData, null, 4);
+            try {
+                node_fs_1.default.writeFileSync(outputPath, jsonContent);
+                console.log(`[OK] Saved credentials to: ${outputPath}`);
+            }
+            catch (e) {
+                console.error(`[ERR] Failed to save to ${outputPath}: ${e.message}`);
+                throw e;
+            }
+        }
+        console.log("\n------------------------------------------");
+        console.log("SUCCESS! Setup complete.");
+        console.log("------------------------------------------");
+        return credentialsData;
+    }
+    finally {
+        if (browser)
+            await browser.close();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"login-helper.js","sourceRoot":"","sources":["../../src/auth/login-helper.ts"],"names":[],"mappings":"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","sourcesContent":["import puppeteer from 'puppeteer';\r\nimport fs from 'node:fs';\r\nimport path from 'node:path';\r\n\r\nexport interface CreateSessionOptions {\r\n    headless?: boolean;\r\n    outputPath?: string;\r\n}\r\n\r\nexport async function createSession(options: CreateSessionOptions = {}) {\r\n    const { headless = false, outputPath } = options;\r\n\r\n    console.log(\"------------------------------------------\");\r\n    console.log(\"   Finary Setup - Browser Login\");\r\n    console.log(\"------------------------------------------\");\r\n\r\n    if (outputPath) {\r\n        // Ensure directory exists\r\n        const dir = path.dirname(outputPath);\r\n        if (!fs.existsSync(dir)) {\r\n            try {\r\n                fs.mkdirSync(dir, { recursive: true });\r\n            } catch (e: any) {\r\n                throw new Error(`Error creating directory ${dir}: ${e.message}`);\r\n            }\r\n        }\r\n        console.log(`Will save to: ${outputPath}`);\r\n    }\r\n\r\n    console.log(\"Launching browser for authentication...\");\r\n\r\n    let browser;\r\n    try {\r\n        browser = await puppeteer.launch({\r\n            headless: headless,\r\n            defaultViewport: null,\r\n            args: ['--start-maximized'] // Find browser window easier\r\n        });\r\n    } catch (e: any) {\r\n        console.error(\"Failed to launch browser. Make sure you installed puppeteer: npm install puppeteer\");\r\n        throw e;\r\n    }\r\n\r\n    try {\r\n        const page = await browser.newPage();\r\n\r\n        await page.setRequestInterception(false); // Ensure interception does not block unless intended\r\n        page.on('request', request => {\r\n            const url = request.url();\r\n            if (url.includes('clerk.finary.com')) {\r\n                // Optional: log or handle clerk requests\r\n            }\r\n        });\r\n\r\n        console.log(\"Navigating to Finary login page...\");\r\n        await page.goto('https://app.finary.com/v2', { waitUntil: 'domcontentloaded' });\r\n\r\n        console.log(\"\\nACTION REQUIRED: Please log in to your Finary account in the opened browser window.\\n\");\r\n        console.log(\"Scanning network traffic for authentication token...\");\r\n\r\n        // Promise that resolves when the valid token is found\r\n        const waitForToken = new Promise<{ token: string, headers: Record<string, string> }>((resolve) => {\r\n            page.on('response', response => {\r\n                const request = response.request();\r\n                const url = request.url();\r\n\r\n                // Filter API requests\r\n                if (url.includes('api.finary.com') || url.includes('clerk.finary.com')) {\r\n                    // We only want successful requests to ensure the token is valid\r\n                    if (response.status() === 200) {\r\n                        const headers = request.headers();\r\n                        const auth = headers['authorization'];\r\n\r\n                        if (auth && auth.startsWith('Bearer ey')) {\r\n                            const token = auth.replace('Bearer ', '');\r\n                            console.log(\"✅ Valid token successfully detected from successful request!\");\r\n                            resolve({ token, headers });\r\n                        }\r\n                    }\r\n                }\r\n            });\r\n        });\r\n\r\n        const { token, headers } = await waitForToken;\r\n\r\n        console.log(\"Token detected! capturing cookies...\");\r\n        // Capture cookies for both the main app and the clerk subdomain to ensure we get __client, __session, etc.\r\n        const cookies = await page.cookies('https://app.finary.com', 'https://clerk.finary.com');\r\n        const cookieHeader = cookies.map(c => `${c.name}=${c.value}`).join('; ');\r\n\r\n        const sessionCookie = cookies.find(c => c.name === '__session');\r\n        const clerkSession = sessionCookie ? sessionCookie.value : null;\r\n\r\n        if (cookieHeader) {\r\n            console.log(\"✅ Cookies captured!\");\r\n        } else {\r\n            console.warn(\"⚠️ No cookies found. Refresh verify might fail.\");\r\n        }\r\n\r\n        console.log(\"Fetching user details...\");\r\n\r\n        // Use the token to identify the user\r\n        let email = \"unknown_user@example.com\";\r\n        try {\r\n            const meResp = await fetch(\"https://api.finary.com/users/me\", {\r\n                headers: {\r\n                    \"Authorization\": `Bearer ${token}`,\r\n                    \"User-Agent\": \"Mozilla/5.0\"\r\n                }\r\n            });\r\n\r\n            if (meResp.ok) {\r\n                const data = await meResp.json();\r\n                if (data.result && data.result.email) {\r\n                    email = data.result.email;\r\n                    console.log(`Identified as: ${email}`);\r\n                }\r\n            }\r\n        } catch (e: any) {\r\n            console.warn(\"Could not fetch user email (minor issue), proceeding anyway.\");\r\n        }\r\n\r\n        // Filter headers based on user request (\"only these specific headers\")\r\n        const allowedHeaderKeys = [\r\n            \"sec-ch-ua-platform\",\r\n            \"x-client-api-version\",\r\n            \"referer\",\r\n            \"accept-language\",\r\n            \"sec-ch-ua\",\r\n            \"sec-ch-ua-mobile\",\r\n            \"user-agent\",\r\n            \"x-finary-client-id\",\r\n            \":authority\",\r\n            \":method\",\r\n            \":scheme\",\r\n            \"accept\",\r\n            \"accept-encoding\",\r\n            \"origin\",\r\n            \"priority\",\r\n            \"sec-fetch-dest\",\r\n            \"sec-fetch-mode\",\r\n            \"sec-fetch-site\"\r\n        ];\r\n\r\n        const filteredHeaders: Record<string, string> = {};\r\n        for (const key of allowedHeaderKeys) {\r\n            if (headers[key]) {\r\n                filteredHeaders[key] = headers[key];\r\n            }\r\n        }\r\n\r\n        const credentialsData = {\r\n            token: token,\r\n            refreshUrl: \"https://clerk.finary.com/v1/client/sessions\",\r\n            headers: filteredHeaders,\r\n            clerkSession: clerkSession, // Kept for backward compatibility\r\n            cookieHeader: cookieHeader,\r\n        };\r\n\r\n        if (outputPath) {\r\n            const jsonContent = JSON.stringify(credentialsData, null, 4);\r\n            try {\r\n                fs.writeFileSync(outputPath, jsonContent);\r\n                console.log(`[OK] Saved credentials to: ${outputPath}`);\r\n            } catch (e: any) {\r\n                console.error(`[ERR] Failed to save to ${outputPath}: ${e.message}`);\r\n                throw e;\r\n            }\r\n        }\r\n\r\n        console.log(\"\\n------------------------------------------\");\r\n        console.log(\"SUCCESS! Setup complete.\");\r\n        console.log(\"------------------------------------------\");\r\n\r\n        return credentialsData;\r\n\r\n    } finally {\r\n        if (browser) await browser.close();\r\n    }\r\n}\r\n"]}

package/dist/client/benchmarks.d.ts

@@ -0,0 +1,7 @@
+import { BenchmarkAsset, FinaryPeriod } from "../interfaces";
+import { RequestHandler } from "./checkings";
+export declare class BenchmarkClient {
+    private requestHandler;
+    constructor(requestHandler: RequestHandler);
+    getAvailableAssets(organizationId: string, membershipId: string, period?: FinaryPeriod): Promise<BenchmarkAsset[]>;
+}

package/dist/client/benchmarks.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BenchmarkClient = void 0;
+const interfaces_1 = require("../interfaces");
+class BenchmarkClient {
+    constructor(requestHandler) {
+        this.requestHandler = requestHandler;
+    }
+    async getAvailableAssets(organizationId, membershipId, period = interfaces_1.FinaryPeriod.YTD) {
+        const response = await this.requestHandler.authenticatedRequest(`/organizations/${organizationId}/memberships/${membershipId}/benchmarks/available_assets?period=${period}`);
+        return response.result;
+    }
+}
+exports.BenchmarkClient = BenchmarkClient;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmVuY2htYXJrcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jbGllbnQvYmVuY2htYXJrcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSw4Q0FBNkU7QUFHN0UsTUFBYSxlQUFlO0lBQ3hCLFlBQW9CLGNBQThCO1FBQTlCLG1CQUFjLEdBQWQsY0FBYyxDQUFnQjtJQUFJLENBQUM7SUFFaEQsS0FBSyxDQUFDLGtCQUFrQixDQUFDLGNBQXNCLEVBQUUsWUFBb0IsRUFBRSxTQUF1Qix5QkFBWSxDQUFDLEdBQUc7UUFDakgsTUFBTSxRQUFRLEdBQUcsTUFBTSxJQUFJLENBQUMsY0FBYyxDQUFDLG9CQUFvQixDQUMzRCxrQkFBa0IsY0FBYyxnQkFBZ0IsWUFBWSx1Q0FBdUMsTUFBTSxFQUFFLENBQzlHLENBQUM7UUFDRixPQUFPLFFBQVEsQ0FBQyxNQUFNLENBQUM7SUFDM0IsQ0FBQztDQUNKO0FBVEQsMENBU0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGaW5hcnlSZXNwb25zZSwgQmVuY2htYXJrQXNzZXQsIEZpbmFyeVBlcmlvZCB9IGZyb20gXCIuLi9pbnRlcmZhY2VzXCI7XHJcbmltcG9ydCB7IFJlcXVlc3RIYW5kbGVyIH0gZnJvbSBcIi4vY2hlY2tpbmdzXCI7XHJcblxyXG5leHBvcnQgY2xhc3MgQmVuY2htYXJrQ2xpZW50IHtcclxuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgcmVxdWVzdEhhbmRsZXI6IFJlcXVlc3RIYW5kbGVyKSB7IH1cclxuXHJcbiAgICBwdWJsaWMgYXN5bmMgZ2V0QXZhaWxhYmxlQXNzZXRzKG9yZ2FuaXphdGlvbklkOiBzdHJpbmcsIG1lbWJlcnNoaXBJZDogc3RyaW5nLCBwZXJpb2Q6IEZpbmFyeVBlcmlvZCA9IEZpbmFyeVBlcmlvZC5ZVEQpOiBQcm9taXNlPEJlbmNobWFya0Fzc2V0W10+IHtcclxuICAgICAgICBjb25zdCByZXNwb25zZSA9IGF3YWl0IHRoaXMucmVxdWVzdEhhbmRsZXIuYXV0aGVudGljYXRlZFJlcXVlc3Q8RmluYXJ5UmVzcG9uc2U8QmVuY2htYXJrQXNzZXRbXT4+KFxyXG4gICAgICAgICAgICBgL29yZ2FuaXphdGlvbnMvJHtvcmdhbml6YXRpb25JZH0vbWVtYmVyc2hpcHMvJHttZW1iZXJzaGlwSWR9L2JlbmNobWFya3MvYXZhaWxhYmxlX2Fzc2V0cz9wZXJpb2Q9JHtwZXJpb2R9YFxyXG4gICAgICAgICk7XHJcbiAgICAgICAgcmV0dXJuIHJlc3BvbnNlLnJlc3VsdDtcclxuICAgIH1cclxufVxyXG4iXX0=

package/dist/client/checkings.d.ts

@@ -0,0 +1,15 @@
+import { CheckingAccount, CheckingPortfolio, FinaryPeriod, Timeseries, TimeseriesType, Distribution, DistributionType, Transaction } from "../interfaces";
+export interface RequestHandler {
+    authenticatedRequest<T>(endpoint: string, method?: string, body?: any): Promise<T>;
+}
+export declare class CheckingClient {
+    private requestHandler;
+    constructor(requestHandler: RequestHandler);
+    getAccounts(organizationId: string, membershipId: string, period?: FinaryPeriod): Promise<CheckingAccount[]>;
+    getAccount(organizationId: string, membershipId: string, accountId: string, period?: FinaryPeriod): Promise<CheckingAccount>;
+    getPortfolio(organizationId: string, membershipId: string, period?: FinaryPeriod): Promise<CheckingPortfolio>;
+    getTimeseries(organizationId: string, membershipId: string, period?: FinaryPeriod, type?: TimeseriesType): Promise<Timeseries[]>;
+    getAccountTimeseries(organizationId: string, membershipId: string, accountId: string, period?: FinaryPeriod, type?: TimeseriesType): Promise<Timeseries[]>;
+    getDistribution(organizationId: string, membershipId: string, type?: DistributionType): Promise<Distribution>;
+    getTransactions(organizationId: string, membershipId: string, page?: number, perPage?: number, query?: string, accountId?: string): Promise<Transaction[]>;
+}