ebag 0.0.2

package/dist/cli/index.js

@@ -0,0 +1,447 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const commander_1 = require("commander");
+const cart_1 = require("../lib/cart");
+const auth_1 = require("../lib/auth");
+const cookies_1 = require("../lib/cookies");
+const config_1 = require("../lib/config");
+const lists_1 = require("../lib/lists");
+const orders_1 = require("../lib/orders");
+const products_1 = require("../lib/products");
+const search_1 = require("../lib/search");
+const slots_1 = require("../lib/slots");
+const format_1 = require("./format");
+function requireSessionCookie() {
+    const session = (0, config_1.loadSession)();
+    if (!session.cookies) {
+        throw new Error('No session cookie found. Run `ebag login --cookie "<cookie>"` first.');
+    }
+    return session;
+}
+function formatError(err) {
+    const error = err;
+    const details = { message: error.message };
+    if (error.status)
+        details.status = error.status;
+    if (error.body)
+        details.body = error.body;
+    return details;
+}
+async function main() {
+    const program = new commander_1.Command();
+    function getPackageVersion() {
+        try {
+            const packagePath = node_path_1.default.resolve(__dirname, '../../package.json');
+            const raw = node_fs_1.default.readFileSync(packagePath, 'utf8');
+            const parsed = JSON.parse(raw);
+            return parsed.version || 'unknown';
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    program
+        .name('ebag')
+        .description('CLI for interacting with ebag.bg')
+        .version(getPackageVersion(), '-v, --version', 'Show CLI version')
+        .option('--json', 'Output JSON');
+    program
+        .command('login')
+        .description('Store session cookie and validate it')
+        .option('--cookie <cookie>', 'Cookie header value from browser')
+        .action(async (options) => {
+        const config = (0, config_1.loadConfig)();
+        const json = program.opts().json;
+        if (!options.cookie) {
+            if (json) {
+                (0, format_1.outputJson)({ instructions: (0, auth_1.getLoginInstructions)() });
+            }
+            else {
+                process.stdout.write(`${(0, auth_1.getLoginInstructions)()}\n`);
+            }
+            return;
+        }
+        const normalizedCookie = (0, cookies_1.normalizeCookieInput)(options.cookie);
+        const cookieError = (0, cookies_1.validateCookieInput)(normalizedCookie);
+        if (cookieError) {
+            throw new Error(`${cookieError} Run \`ebag login --cookie "<cookie>"\` with a Cookie header value.`);
+        }
+        try {
+            const session = {
+                cookies: normalizedCookie,
+                updatedAt: new Date().toISOString(),
+            };
+            const user = await (0, auth_1.validateSession)(config, session);
+            const email = user.email ||
+                user.username;
+            if (!email) {
+                throw new Error('Session validated but no user email was returned.');
+            }
+            (0, config_1.saveSession)(session);
+            if (json) {
+                (0, format_1.outputJson)({ status: 'ok', user, email });
+            }
+            else {
+                process.stdout.write('Login session validated and saved.\n');
+                process.stdout.write(`Logged in as: ${email}\n`);
+            }
+        }
+        catch (err) {
+            if (json) {
+                (0, format_1.outputJson)({ status: 'error', message: err.message });
+            }
+            else {
+                process.stderr.write(`Login failed: ${err.message}\n`);
+            }
+        }
+    });
+    program
+        .command('status')
+        .description('Show current login status')
+        .action(async () => {
+        const config = (0, config_1.loadConfig)();
+        const json = program.opts().json;
+        const session = (0, config_1.loadSession)();
+        if (!session.cookies) {
+            if (json) {
+                (0, format_1.outputJson)({ status: 'logged_out' });
+            }
+            else {
+                process.stdout.write('Logged out (no session cookie).\n');
+            }
+            return;
+        }
+        try {
+            const user = await (0, auth_1.validateSession)(config, session);
+            const email = user.email || user.username;
+            if (json) {
+                (0, format_1.outputJson)({ status: 'logged_in', user, email });
+            }
+            else {
+                process.stdout.write('Logged in.\n');
+                if (email) {
+                    process.stdout.write(`Email: ${email}\n`);
+                }
+            }
+        }
+        catch (err) {
+            const error = err;
+            if (error.status && [401, 403].includes(error.status)) {
+                if (json) {
+                    (0, format_1.outputJson)({ status: 'logged_out' });
+                }
+                else {
+                    process.stdout.write('Logged out.\n');
+                }
+                return;
+            }
+            throw err;
+        }
+    });
+    program
+        .command('slots')
+        .description('Show the next available delivery slots')
+        .option('--limit <n>', 'Limit number of slots', '10')
+        .action(async (options) => {
+        const config = (0, config_1.loadConfig)();
+        const session = requireSessionCookie();
+        const json = program.opts().json;
+        const limit = Number(options.limit);
+        const slotsPayload = await (0, orders_1.getTimeSlots)(config, session);
+        const slots = (0, slots_1.normalizeSlots)(slotsPayload).filter((slot) => slot.isAvailable);
+        slots.sort(slots_1.sortSlots);
+        const limited = slots.slice(0, Number.isFinite(limit) ? limit : 10);
+        if (json) {
+            (0, format_1.outputJson)({ slots: limited });
+            return;
+        }
+        if (!limited.length) {
+            process.stdout.write('No available delivery slots.\n');
+            return;
+        }
+        const today = new Date();
+        const todayDate = today.toISOString().slice(0, 10);
+        const tomorrow = new Date(today);
+        tomorrow.setDate(today.getDate() + 1);
+        const tomorrowDate = tomorrow.toISOString().slice(0, 10);
+        let currentDate = '';
+        let printedHeader = false;
+        for (const slot of limited) {
+            if (slot.date !== currentDate) {
+                currentDate = slot.date;
+                let label = currentDate;
+                if (currentDate === todayDate) {
+                    label = `Today (${currentDate})`;
+                }
+                else if (currentDate === tomorrowDate) {
+                    label = `Tomorrow (${currentDate})`;
+                }
+                const headerPrefix = printedHeader ? '\n' : '';
+                process.stdout.write(`${headerPrefix}${(0, format_1.formatHeading)(`# ${label}`)}\n`);
+                printedHeader = true;
+            }
+            process.stdout.write(`${(0, slots_1.formatSlotRange)(slot.start, slot.end)} (${(0, slots_1.formatLoadPercent)(slot.loadPercent)})\n`);
+        }
+    });
+    program
+        .command('search')
+        .description('Search for products')
+        .argument('<query>', 'Search query')
+        .option('--limit <n>', 'Limit number of results', '20')
+        .option('--page <n>', 'Algolia page number (0-based)', '0')
+        .action(async (query, options) => {
+        const config = (0, config_1.loadConfig)();
+        const session = (0, config_1.loadSession)();
+        const json = program.opts().json;
+        const limit = Number(options.limit);
+        const page = Number(options.page);
+        const result = await (0, search_1.searchProducts)(config, session, query, { limit, page });
+        if (json) {
+            (0, format_1.outputJson)(result);
+        }
+        else {
+            (0, format_1.outputProducts)(result.results);
+        }
+    });
+    program
+        .command('product')
+        .description('Get product details by ID')
+        .argument('<productId>', 'Product ID')
+        .action(async (productId) => {
+        const config = (0, config_1.loadConfig)();
+        const session = (0, config_1.loadSession)();
+        const json = program.opts().json;
+        const result = await (0, products_1.getProductById)(config, session, Number(productId));
+        if (json) {
+            (0, format_1.outputJson)(result);
+        }
+        else {
+            (0, format_1.outputProductDetail)(result);
+        }
+    });
+    const order = program.command('order').description('Order operations');
+    order
+        .command('list')
+        .description('List recent orders')
+        .option('--limit <n>', 'Limit number of results', '10')
+        .option('--page <n>', 'Page number')
+        .option('--from <date>', 'Filter from date (YYYY-MM-DD)')
+        .option('--to <date>', 'Filter to date (YYYY-MM-DD)')
+        .action(async (options) => {
+        const config = (0, config_1.loadConfig)();
+        const session = requireSessionCookie();
+        const json = program.opts().json;
+        const limit = Number(options.limit);
+        const page = options.page ? Number(options.page) : undefined;
+        const from = options.from;
+        const to = options.to;
+        const result = await (0, orders_1.listOrders)(config, session, {
+            limit: Number.isFinite(limit) ? limit : 10,
+            page: page !== undefined && Number.isFinite(page) ? page : undefined,
+            from,
+            to,
+        });
+        if (json) {
+            (0, format_1.outputJson)(result);
+        }
+        else if (!result.results.length) {
+            process.stdout.write('No orders found.\n');
+        }
+        else {
+            (0, format_1.outputOrdersList)(result.results);
+        }
+    });
+    order
+        .command('show')
+        .description('Show order details')
+        .argument('<orderId>', 'Order ID')
+        .action(async (orderId) => {
+        const config = (0, config_1.loadConfig)();
+        const session = requireSessionCookie();
+        const json = program.opts().json;
+        const detail = await (0, orders_1.getOrderDetail)(config, session, String(orderId));
+        if (json) {
+            (0, format_1.outputJson)(detail);
+        }
+        else {
+            (0, format_1.outputOrderDetail)(detail);
+        }
+    });
+    const cart = program.command('cart').description('Cart operations');
+    cart
+        .command('add')
+        .argument('<productId>', 'Product ID')
+        .option('--qty <n>', 'Quantity', '1')
+        .action(async (productId, options) => {
+        const config = (0, config_1.loadConfig)();
+        const session = requireSessionCookie();
+        const json = program.opts().json;
+        const qty = Number(options.qty);
+        const result = await (0, cart_1.addToCart)(config, session, Number(productId), qty);
+        if (json) {
+            (0, format_1.outputJson)(result);
+        }
+        else {
+            process.stdout.write('Added to cart.\n');
+        }
+    });
+    cart
+        .command('update')
+        .argument('<productId>', 'Product ID')
+        .option('--qty <n>', 'Quantity', '1')
+        .action(async (productId, options) => {
+        const config = (0, config_1.loadConfig)();
+        const session = requireSessionCookie();
+        const json = program.opts().json;
+        const qty = Number(options.qty);
+        const result = await (0, cart_1.updateCart)(config, session, Number(productId), qty);
+        if (json) {
+            (0, format_1.outputJson)(result);
+        }
+        else {
+            process.stdout.write('Cart updated.\n');
+        }
+    });
+    cart
+        .command('show')
+        .description('Show cart contents')
+        .action(async () => {
+        const config = (0, config_1.loadConfig)();
+        const session = requireSessionCookie();
+        const json = program.opts().json;
+        const cartData = await (0, cart_1.getCart)(config, session);
+        if (json) {
+            (0, format_1.outputJson)(cartData);
+            return;
+        }
+        const items = Array.isArray(cartData.items)
+            ? cartData.items
+            : [];
+        const listItems = items
+            .map((item) => {
+            const entry = item;
+            const id = entry.product?.id ?? entry.product_id ?? entry.productId ?? entry.id;
+            const name = entry.product?.name ?? entry.name ?? 'Unknown';
+            const count = entry.quantity ?? entry.qty;
+            if (!id)
+                return null;
+            return { id: Number(id), name, count };
+        })
+            .filter(Boolean);
+        if (listItems.length) {
+            (0, format_1.outputList)(listItems);
+        }
+        else {
+            process.stdout.write('Cart is empty.\n');
+        }
+    });
+    const list = program.command('list').description('List operations');
+    list
+        .command('show')
+        .description('Show your lists')
+        .argument('[listId]', 'List ID')
+        .action(async (listId) => {
+        const config = (0, config_1.loadConfig)();
+        const session = requireSessionCookie();
+        const json = program.opts().json;
+        const lists = await (0, lists_1.getLists)(config, session);
+        if (listId) {
+            const listEntry = lists.find((item) => Number(item.id) === Number(listId));
+            if (!listEntry) {
+                throw new Error(`List ${listId} not found.`);
+            }
+            const listItems = await (0, lists_1.getListItems)(config, session, Number(listId));
+            const results = Array.isArray(listItems.results)
+                ? listItems.results
+                : [];
+            const count = typeof listItems.count === 'number'
+                ? listItems.count
+                : results.length;
+            if (json) {
+                (0, format_1.outputJson)({
+                    ...listEntry,
+                    count,
+                    items: results,
+                    next: listItems.next ?? null,
+                    previous: listItems.previous ?? null,
+                });
+            }
+            else {
+                process.stdout.write(`${listEntry.name} (${listEntry.id})`);
+                if (!count) {
+                    process.stdout.write(' - empty\n');
+                    return;
+                }
+                process.stdout.write(` - ${count} items\n`);
+                const outputItems = results
+                    .map((item) => {
+                    const entry = item;
+                    const product = entry.product;
+                    const id = product?.id ?? entry.product_id ?? entry.productId ?? entry.id;
+                    const name = product?.name ?? entry.name ?? 'Unknown';
+                    const itemCount = entry.quantity ?? entry.qty;
+                    if (!id)
+                        return null;
+                    return { id: Number(id), name, count: itemCount };
+                })
+                    .filter(Boolean);
+                (0, format_1.outputList)(outputItems);
+            }
+            return;
+        }
+        if (json) {
+            (0, format_1.outputJson)(lists);
+            return;
+        }
+        (0, format_1.outputList)(lists.map((item) => ({
+            id: item.id,
+            name: item.name,
+            count: item.products?.length,
+        })));
+    });
+    list
+        .command('add')
+        .argument('<listId>', 'List ID')
+        .argument('<productId>', 'Product ID')
+        .option('--qty <n>', 'Quantity', '1')
+        .action(async (listId, productId, options) => {
+        const config = (0, config_1.loadConfig)();
+        const session = requireSessionCookie();
+        const json = program.opts().json;
+        const qty = Number(options.qty);
+        const result = await (0, lists_1.addToList)(config, session, Number(listId), Number(productId), qty);
+        if (json) {
+            (0, format_1.outputJson)(result);
+        }
+        else {
+            process.stdout.write('Added to list.\n');
+        }
+    });
+    try {
+        await program.parseAsync(process.argv);
+    }
+    catch (err) {
+        const json = program.opts().json;
+        if (json) {
+            (0, format_1.outputJson)({ status: 'error', ...formatError(err) });
+        }
+        else {
+            const details = formatError(err);
+            process.stderr.write(`${details.message}\n`);
+            if (details.status) {
+                process.stderr.write(`Status: ${details.status}\n`);
+            }
+            if (details.body) {
+                process.stderr.write(`Body: ${details.body}\n`);
+            }
+        }
+        process.exit(1);
+    }
+}
+main();

package/dist/lib/auth.d.ts

@@ -0,0 +1,3 @@
+import type { Config, Session } from './types';
+export declare function getLoginInstructions(): string;
+export declare function validateSession(config: Config, session: Session): Promise<unknown>;

package/dist/lib/auth.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLoginInstructions = getLoginInstructions;
+exports.validateSession = validateSession;
+const client_1 = require("./client");
+function getLoginInstructions() {
+    return [
+        '1) Log in to https://www.ebag.bg in your browser.',
+        '2) Open DevTools > Network and click any request to https://www.ebag.bg (not a static asset).',
+        '3) In the request headers, copy the full Cookie header value (semicolon-separated).',
+        '4) Run: ebag login --cookie "<cookie>"',
+    ].join('\n');
+}
+async function validateSession(config, session) {
+    const result = await (0, client_1.requestEbag)(config, session, '/user/json');
+    return result.data;
+}

package/dist/lib/cart.d.ts

@@ -0,0 +1,4 @@
+import type { Config, Session } from './types';
+export declare function addToCart(config: Config, session: Session, productId: number, quantity: number, unitTypeOverride?: string): Promise<unknown>;
+export declare function updateCart(config: Config, session: Session, productId: number, quantity: number, unitTypeOverride?: string): Promise<unknown>;
+export declare function getCart(config: Config, session: Session): Promise<unknown>;

package/dist/lib/cart.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addToCart = addToCart;
+exports.updateCart = updateCart;
+exports.getCart = getCart;
+const client_1 = require("./client");
+async function addToCart(config, session, productId, quantity, unitTypeOverride = 'false') {
+    const baseUrl = config.baseUrl || 'https://www.ebag.bg';
+    const body = new URLSearchParams({
+        product_id: String(productId),
+        quantity: String(quantity),
+        unit_type_override: unitTypeOverride,
+    });
+    const result = await (0, client_1.requestEbag)(config, session, '/cart/add', {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
+            origin: baseUrl,
+            referer: `${baseUrl}/search/`,
+        },
+        body,
+    });
+    return result.data;
+}
+async function updateCart(config, session, productId, quantity, unitTypeOverride = 'false') {
+    const baseUrl = config.baseUrl || 'https://www.ebag.bg';
+    const body = new URLSearchParams({
+        product_id: String(productId),
+        quantity: String(quantity),
+        unit_type_override: unitTypeOverride,
+    });
+    const result = await (0, client_1.requestEbag)(config, session, '/cart/update', {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
+            origin: baseUrl,
+            referer: `${baseUrl}/search/`,
+        },
+        body,
+    });
+    return result.data;
+}
+async function getCart(config, session) {
+    const result = await (0, client_1.requestEbag)(config, session, '/cart/json');
+    return result.data;
+}

package/dist/lib/client.d.ts

@@ -0,0 +1,13 @@
+import type { Config, Session } from './types';
+export type RequestResult<T> = {
+    status: number;
+    data: T;
+    headers: Record<string, string>;
+};
+export declare function requestEbag<T>(config: Config, session: Session, path: string, options?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string | URLSearchParams;
+    query?: Record<string, string | number | undefined>;
+}): Promise<RequestResult<T>>;
+export declare function requestAlgolia<T>(config: Config, body: unknown): Promise<RequestResult<T>>;

package/dist/lib/client.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestEbag = requestEbag;
+exports.requestAlgolia = requestAlgolia;
+function normalizeHeaders(headers) {
+    const out = {};
+    headers.forEach((value, key) => {
+        out[key] = value;
+    });
+    return out;
+}
+function getCookieValue(cookies, name) {
+    if (!cookies)
+        return undefined;
+    const parts = cookies.split(';').map((part) => part.trim());
+    for (const part of parts) {
+        if (part.startsWith(`${name}=`)) {
+            return part.slice(name.length + 1);
+        }
+    }
+    return undefined;
+}
+async function requestEbag(config, session, path, options = {}) {
+    const baseUrl = config.baseUrl || 'https://www.ebag.bg';
+    const url = new URL(path, baseUrl);
+    if (options.query) {
+        for (const [key, value] of Object.entries(options.query)) {
+            if (value !== undefined) {
+                url.searchParams.set(key, String(value));
+            }
+        }
+    }
+    const headers = {
+        accept: 'application/json, text/plain, */*',
+        ...options.headers,
+    };
+    if (session.cookies) {
+        headers.cookie = session.cookies;
+    }
+    const method = (options.method || 'GET').toUpperCase();
+    if (!headers['x-csrftoken'] && method !== 'GET') {
+        const token = getCookieValue(session.cookies, 'csrftoken');
+        if (token) {
+            headers['x-csrftoken'] = token;
+        }
+    }
+    const response = await fetch(url.toString(), {
+        method,
+        headers,
+        body: options.body instanceof URLSearchParams ? options.body.toString() : options.body,
+    });
+    const contentType = response.headers.get('content-type') || '';
+    const raw = await response.text();
+    const data = contentType.includes('application/json') ? JSON.parse(raw) : raw;
+    if (!response.ok) {
+        const err = new Error(`Request failed ${response.status} ${url}`);
+        err.status = response.status;
+        err.body = raw;
+        throw err;
+    }
+    return {
+        status: response.status,
+        data,
+        headers: normalizeHeaders(response.headers),
+    };
+}
+async function requestAlgolia(config, body) {
+    const host = config.algolia?.host || 'jmjmdq9hhx-dsn.algolia.net';
+    const appId = config.algolia?.appId || 'JMJMDQ9HHX';
+    const apiKey = config.algolia?.apiKey || '42ca9458d9354298c7016ce9155d8481';
+    const url = new URL(`/1/indexes/*/queries`, `https://${host}`);
+    url.searchParams.set('x-algolia-agent', 'Algolia for JavaScript (4.24.0); Browser; instantsearch.js (4.80.0)');
+    const response = await fetch(url.toString(), {
+        method: 'POST',
+        headers: {
+            'x-algolia-application-id': appId,
+            'x-algolia-api-key': apiKey,
+            'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
+        },
+        body: JSON.stringify(body),
+    });
+    const contentType = response.headers.get('content-type') || '';
+    const raw = await response.text();
+    const data = contentType.includes('application/json') ? JSON.parse(raw) : raw;
+    if (!response.ok) {
+        const err = new Error(`Algolia request failed ${response.status}`);
+        err.status = response.status;
+        err.body = raw;
+        throw err;
+    }
+    return {
+        status: response.status,
+        data,
+        headers: normalizeHeaders(response.headers),
+    };
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,11 @@
+import type { Cache, Config, Session } from './types';
+export declare function getConfigDir(): string;
+export declare function getConfigPath(): string;
+export declare function getSessionPath(): string;
+export declare function getCachePath(): string;
+export declare function loadConfig(): Config;
+export declare function saveConfig(config: Config): void;
+export declare function loadSession(): Session;
+export declare function saveSession(session: Session): void;
+export declare function loadCache(): Cache;
+export declare function saveCache(cache: Cache): void;