kvitton-cli 0.4.2

package/dist/commands/company-info.js

@@ -0,0 +1,48 @@
+import ora from "ora";
+import { loadConfig } from "../lib/env";
+import { createBokioClient } from "../lib/client";
+export async function companyInfoCommand() {
+    const cwd = process.cwd();
+    // Load config
+    const spinner = ora("Loading configuration...").start();
+    let config;
+    try {
+        config = loadConfig(cwd);
+        spinner.succeed(`Provider: ${config.provider}`);
+    }
+    catch (error) {
+        spinner.fail(error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+    }
+    // Create client
+    const client = createBokioClient(config);
+    // Fetch company info
+    const infoSpinner = ora("Fetching company information...").start();
+    try {
+        const companyInfo = await client.getCompanyInformation();
+        infoSpinner.stop();
+        console.log(`
+  Company Information
+  -------------------
+  Name:            ${companyInfo.name}
+  Org Number:      ${companyInfo.organizationNumber ?? "N/A"}
+  VAT Number:      ${companyInfo.vatNumber ?? "N/A"}
+  Address:         ${formatAddress(companyInfo.address)}
+`);
+    }
+    catch (error) {
+        infoSpinner.fail("Failed to fetch company information");
+        console.error(error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+    }
+}
+function formatAddress(address) {
+    if (!address)
+        return "N/A";
+    const parts = [
+        address.street,
+        [address.zipCode, address.city].filter(Boolean).join(" "),
+        address.country,
+    ].filter(Boolean);
+    return parts.length > 0 ? parts.join(", ") : "N/A";
+}

package/dist/commands/convert-currency.js

@@ -0,0 +1,76 @@
+import { RiksbankClient } from "integrations-riksbank";
+import { getCachedRate, setCachedRate } from "../lib/currency-cache";
+function getToday() {
+    return new Date().toISOString().slice(0, 10);
+}
+export async function convertCurrencyCommand(options) {
+    const cwd = process.cwd();
+    const amount = parseFloat(options.amount);
+    const currency = options.currency.toUpperCase();
+    const date = options.date ?? getToday();
+    // Validate amount
+    if (Number.isNaN(amount) || amount <= 0) {
+        console.error("Error: --amount must be a positive number");
+        process.exit(1);
+    }
+    // Validate date format
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
+        console.error("Error: --date must be in YYYY-MM-DD format");
+        process.exit(1);
+    }
+    // Handle SEK (no conversion needed)
+    if (currency === "SEK") {
+        console.log("Currency Conversion");
+        console.log("===================");
+        console.log(`Amount: ${amount.toFixed(2)} SEK`);
+        console.log(`Date: ${date}`);
+        console.log("");
+        console.log("No conversion needed (already SEK)");
+        console.log("");
+        console.log(`Result: ${amount.toFixed(2)} SEK`);
+        return;
+    }
+    // Initialize Riksbank client
+    const riksbank = new RiksbankClient();
+    // Validate currency is supported
+    if (!riksbank.isSupportedCurrency(currency)) {
+        console.error(`Error: Unsupported currency: ${currency}`);
+        console.error(`Supported currencies: ${riksbank.getSupportedCurrencies().join(", ")}`);
+        process.exit(1);
+    }
+    console.log("Currency Conversion");
+    console.log("===================");
+    console.log(`Amount: ${amount.toFixed(2)} ${currency}`);
+    console.log(`Date: ${date}`);
+    console.log("");
+    // Check cache first
+    const cached = getCachedRate(cwd, currency, date);
+    let rate;
+    let rateDate;
+    let source;
+    if (cached) {
+        rate = cached.rate;
+        rateDate = cached.rateDate;
+        source = "CACHE";
+    }
+    else {
+        // Fetch from Riksbank
+        const result = await riksbank.getRate(currency, date);
+        rate = result.value;
+        rateDate = result.date;
+        source = "RIKSBANK";
+        // Save to cache
+        setCachedRate(cwd, currency, date, rate, rateDate);
+    }
+    const convertedAmount = amount * rate;
+    console.log(`Exchange Rate: ${rate.toFixed(4)} SEK/${currency}`);
+    if (rateDate !== date) {
+        console.log(`Rate Date: ${rateDate} (closest available)`);
+    }
+    else {
+        console.log(`Rate Date: ${rateDate}`);
+    }
+    console.log(`Source: ${source}`);
+    console.log("");
+    console.log(`Converted Amount: ${convertedAmount.toFixed(2)} SEK`);
+}

package/dist/commands/create-entry.js

@@ -0,0 +1,198 @@
+/**
+ * Create a complete journal entry from an inbox document
+ * Reads document.yaml, generates lines, and creates entry.yaml
+ */
+import { RiksbankClient } from "integrations-riksbank";
+import { resolveTaxCode, createJournalLinesFromTaxCode, getAllTaxCodes, } from "shared/dist/accounting";
+import { readAccountsYaml, getAccountName, toYaml } from "shared/dist/yaml";
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+import * as yaml from "yaml";
+export async function createEntryCommand(options) {
+    // Handle --list-tax-codes flag
+    if (options.listTaxCodes) {
+        console.log("Available Tax Codes");
+        console.log("===================");
+        for (const tc of getAllTaxCodes()) {
+            console.log(`  ${tc.code}`);
+            console.log(`    ${tc.description}`);
+            console.log(`    Direction: ${tc.direction} | Territory: ${tc.territory} | Rate: ${tc.ratePercent}%`);
+            console.log("");
+        }
+        return;
+    }
+    const { inboxDir, taxCode: taxCodeStr, baseAccount: baseAccountCode, balancingAccount: balancingAccountCode, series: seriesInput, entryNumber: entryNumberStr, memo, dryRun = false, } = options;
+    const series = seriesInput.toUpperCase();
+    const entryNumber = Number.parseInt(entryNumberStr, 10);
+    if (Number.isNaN(entryNumber) || entryNumber < 1) {
+        console.error("Error: --entry-number must be a positive integer");
+        process.exit(1);
+    }
+    // File paths
+    const documentPath = path.join(inboxDir, "document.yaml");
+    const accountsPath = path.join(path.dirname(inboxDir), "accounts.yaml");
+    // Read document.yaml
+    let documentContent;
+    try {
+        documentContent = await fs.readFile(documentPath, "utf-8");
+    }
+    catch {
+        console.error(`Error: document.yaml not found at ${documentPath}`);
+        process.exit(1);
+    }
+    const document = yaml.parse(documentContent);
+    // Extract data from document
+    const description = document.description || "Unknown vendor";
+    const documentDate = document.documentDate;
+    const totalAmount = document.totalAmount;
+    const subTotal = document.subTotal;
+    if (!documentDate) {
+        console.error("Error: documentDate not found in document.yaml");
+        process.exit(1);
+    }
+    // Determine base amount - use subTotal (net) if available, otherwise totalAmount
+    const amountSource = subTotal || totalAmount;
+    if (!amountSource) {
+        console.error("Error: No amount found in document.yaml (need totalAmount or subTotal)");
+        process.exit(1);
+    }
+    const baseAmount = Number.parseFloat(amountSource.amount);
+    const currency = amountSource.currency || "SEK";
+    if (Number.isNaN(baseAmount) || baseAmount <= 0) {
+        console.error("Error: Invalid amount in document.yaml");
+        process.exit(1);
+    }
+    console.log("Creating Journal Entry");
+    console.log("======================");
+    console.log(`Document: ${document.fileName}`);
+    console.log(`Vendor: ${description}`);
+    console.log(`Date: ${documentDate}`);
+    console.log(`Amount: ${baseAmount.toFixed(2)} ${currency}`);
+    console.log("");
+    // Resolve tax code
+    const taxCode = resolveTaxCode(taxCodeStr);
+    if (!taxCode) {
+        console.error(`Error: Invalid tax code: ${taxCodeStr}`);
+        console.error("\nRun with --list-tax-codes to see available codes");
+        process.exit(1);
+    }
+    console.log(`Tax Code: ${taxCode.code}`);
+    console.log(`  ${taxCode.description}`);
+    console.log(`  VAT Rate: ${taxCode.ratePercent}%`);
+    console.log("");
+    // Currency conversion if needed
+    let amountInSEK = baseAmount;
+    if (currency !== "SEK") {
+        console.log(`Converting ${baseAmount.toFixed(2)} ${currency} to SEK...`);
+        const riksbank = new RiksbankClient();
+        if (!riksbank.isSupportedCurrency(currency)) {
+            console.error(`Error: Unsupported currency: ${currency}`);
+            process.exit(1);
+        }
+        const rate = await riksbank.getRate(currency, documentDate);
+        amountInSEK = baseAmount * rate.value;
+        console.log(`  Rate: ${rate.value.toFixed(4)} SEK/${currency} (${rate.date})`);
+        console.log(`  Converted: ${amountInSEK.toFixed(2)} SEK`);
+        console.log("");
+    }
+    // Load accounts for memo lookup
+    let accounts = [];
+    try {
+        accounts = await readAccountsYaml(accountsPath);
+    }
+    catch {
+        // accounts.yaml not found, continue without account names
+    }
+    // Generate journal lines
+    const result = createJournalLinesFromTaxCode({
+        taxCode,
+        baseAmount: amountInSEK,
+        baseAccountCode,
+        balancingAccountCode,
+        memo,
+        startingLineNumber: 1,
+    });
+    // Build entry.yaml content
+    const entryLines = result.lines.map((line) => ({
+        lineNumber: line.line_number,
+        account: line.ledger_account_code,
+        debit: {
+            amount: line.debit ?? 0,
+            currency: "SEK",
+        },
+        credit: {
+            amount: line.credit ?? 0,
+            currency: "SEK",
+        },
+        memo: line.memo ||
+            getAccountName(line.ledger_account_code, accounts) ||
+            undefined,
+    }));
+    const totalDebit = result.lines.reduce((sum, l) => sum + (l.debit ?? 0), 0);
+    const totalCredit = result.lines.reduce((sum, l) => sum + (l.credit ?? 0), 0);
+    const entry = {
+        series,
+        entryNumber,
+        entryDate: documentDate,
+        description,
+        status: "DRAFT",
+        currency: "SEK",
+        totalDebit: {
+            amount: Math.round(totalDebit * 100) / 100,
+            currency: "SEK",
+        },
+        totalCredit: {
+            amount: Math.round(totalCredit * 100) / 100,
+            currency: "SEK",
+        },
+        lines: entryLines,
+    };
+    // Output the entry
+    console.log("Generated Entry:");
+    console.log("-".repeat(40));
+    const entryYaml = toYaml(entry);
+    console.log(entryYaml);
+    console.log("-".repeat(40));
+    console.log(`Total Debit: ${totalDebit.toFixed(2)} SEK`);
+    console.log(`Total Credit: ${totalCredit.toFixed(2)} SEK`);
+    console.log(`Balanced: ${Math.abs(totalDebit - totalCredit) < 0.01 ? "✓" : "✗"}`);
+    // Calculate drafts directory name: {date} - {title}
+    const titleSlug = slugify(description, 30);
+    const draftsDirName = `${documentDate} - ${titleSlug}`;
+    const draftsDir = path.join(path.dirname(inboxDir), "drafts", draftsDirName);
+    // Write entry.yaml and move to drafts unless dry-run
+    if (dryRun) {
+        console.log("\n[Dry run - files not moved]");
+        console.log(`Would move to: ${draftsDir}`);
+    }
+    else {
+        // Create drafts directory
+        await fs.mkdir(draftsDir, { recursive: true });
+        // Copy all files from inbox to drafts
+        const inboxFiles = await fs.readdir(inboxDir);
+        for (const file of inboxFiles) {
+            const srcPath = path.join(inboxDir, file);
+            const destPath = path.join(draftsDir, file);
+            await fs.copyFile(srcPath, destPath);
+        }
+        // Write entry.yaml to drafts
+        const entryPath = path.join(draftsDir, "entry.yaml");
+        await fs.writeFile(entryPath, entryYaml, "utf-8");
+        // Delete inbox directory
+        await fs.rm(inboxDir, { recursive: true });
+        console.log(`\n✓ Moved to ${draftsDir}`);
+        console.log(`✓ Entry written to ${entryPath}`);
+    }
+}
+/**
+ * Convert text to a URL-friendly slug
+ */
+function slugify(text, maxLength = 30) {
+    return text
+        .toLowerCase()
+        .slice(0, maxLength)
+        .replace(/[^a-z0-9\s-]/g, "")
+        .replace(/\s+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "");
+}

package/dist/commands/generate-lines.js

@@ -0,0 +1,140 @@
+/**
+ * Generate journal entry lines from tax codes
+ * Appends lines to an existing entry.yaml
+ */
+import { createClient } from "@supabase/supabase-js";
+import { resolveTaxCode, createJournalLinesFromTaxCode, convertToSEK, calculateLineTotals, getAllTaxCodes, } from "shared/dist/accounting";
+import { readEntryYaml, readDocumentYaml, appendLinesToEntry, readAccountsYaml, validateAccountExists, getAccountName, } from "shared/dist/yaml";
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+export async function generateLinesCommand(options) {
+    const { inboxDir, taxCode: taxCodeStr, baseAmount: baseAmountStr, baseAccount: baseAccountCode, balancingAccount: balancingAccountCode, memo, amountCurrency = "SEK", } = options;
+    const baseAmount = Number.parseFloat(baseAmountStr);
+    // Validate base amount
+    if (Number.isNaN(baseAmount) || baseAmount <= 0) {
+        console.error("Error: --base-amount must be a positive number");
+        process.exit(1);
+    }
+    // File paths
+    const entryPath = path.join(inboxDir, "entry.yaml");
+    const documentPath = path.join(inboxDir, "document.yaml");
+    const accountsPath = path.join(path.dirname(path.dirname(inboxDir)), "accounts.yaml");
+    // Check if files exist
+    try {
+        await fs.access(entryPath);
+    }
+    catch {
+        console.error(`Error: entry.yaml not found at ${entryPath}`);
+        process.exit(1);
+    }
+    try {
+        await fs.access(documentPath);
+    }
+    catch {
+        console.error(`Error: document.yaml not found at ${documentPath}`);
+        process.exit(1);
+    }
+    // Read entry and document
+    console.log("Reading entry and document files...");
+    const entry = await readEntryYaml(entryPath);
+    // Document is read to validate it exists but not directly used
+    await readDocumentYaml(documentPath);
+    console.log(`Entry date: ${entry.entryDate}`);
+    console.log(`Description: ${entry.description}`);
+    // Resolve tax code
+    console.log(`\nResolving tax code: ${taxCodeStr}`);
+    const taxCode = resolveTaxCode(taxCodeStr);
+    if (!taxCode) {
+        console.error(`Error: Invalid tax code: ${taxCodeStr}`);
+        console.error("\nAvailable tax codes:");
+        for (const tc of getAllTaxCodes()) {
+            console.error(`  ${tc.code} - ${tc.description}`);
+        }
+        process.exit(1);
+    }
+    console.log(`✓ Tax code resolved: ${taxCode.description}`);
+    console.log(`  Direction: ${taxCode.direction}`);
+    console.log(`  Territory: ${taxCode.territory}`);
+    console.log(`  VAT Rate: ${taxCode.ratePercent}%`);
+    // Currency conversion if needed
+    let amountInSEK = baseAmount;
+    if (amountCurrency !== "SEK") {
+        console.log(`\nCurrency conversion: ${baseAmount} ${amountCurrency} → SEK`);
+        // Initialize Supabase client
+        const supabaseUrl = process.env.SUPABASE_URL;
+        const supabaseKey = process.env.SUPABASE_SECRET_KEY;
+        if (!supabaseUrl || !supabaseKey) {
+            console.error("Error: Missing Supabase credentials");
+            console.error("Ensure SUPABASE_URL and SUPABASE_SECRET_KEY are set in environment");
+            process.exit(1);
+        }
+        const supabase = createClient(supabaseUrl, supabaseKey);
+        const converted = await convertToSEK(supabase, baseAmount, amountCurrency, entry.entryDate);
+        if (converted === null) {
+            console.error(`Error: No currency rate found for ${amountCurrency} on ${entry.entryDate}`);
+            console.error("Please sync currency rates from Riksbank or provide amount already in SEK");
+            process.exit(1);
+        }
+        amountInSEK = converted;
+        console.log(`✓ Converted to SEK: ${amountInSEK.toFixed(2)}`);
+    }
+    // Validate accounts exist (if accounts.yaml is available)
+    let accounts = [];
+    try {
+        await fs.access(accountsPath);
+        accounts = await readAccountsYaml(accountsPath);
+        console.log(`\nValidating accounts against ${accountsPath}`);
+        if (!validateAccountExists(baseAccountCode, accounts)) {
+            console.error(`Error: Base account ${baseAccountCode} not found`);
+            console.error("Run export-accounts first to create accounts.yaml");
+            process.exit(1);
+        }
+        if (!validateAccountExists(balancingAccountCode, accounts)) {
+            console.error(`Error: Balancing account ${balancingAccountCode} not found`);
+            console.error("Run export-accounts first to create accounts.yaml");
+            process.exit(1);
+        }
+        console.log(`✓ Base account: ${baseAccountCode} - ${getAccountName(baseAccountCode, accounts)}`);
+        console.log(`✓ Balancing account: ${balancingAccountCode} - ${getAccountName(balancingAccountCode, accounts)}`);
+    }
+    catch {
+        console.warn(`\nWarning: accounts.yaml not found at ${accountsPath}, skipping account validation`);
+    }
+    // Generate lines
+    console.log("\nGenerating journal lines...");
+    const result = createJournalLinesFromTaxCode({
+        taxCode,
+        baseAmount: amountInSEK,
+        baseAccountCode,
+        balancingAccountCode,
+        memo,
+        startingLineNumber: (entry.lines?.length || 0) + 1,
+    });
+    console.log(`✓ Generated ${result.lines.length} lines:`);
+    console.log(`  Net amount: ${result.totals.net.toFixed(2)} SEK`);
+    console.log(`  VAT amount: ${result.totals.vat.toFixed(2)} SEK`);
+    console.log(`  Gross amount: ${result.totals.gross.toFixed(2)} SEK`);
+    for (const line of result.lines) {
+        const accountName = getAccountName(line.ledger_account_code, accounts);
+        const debit = line.debit ? `${line.debit.toFixed(2)} SEK` : "-";
+        const credit = line.credit ? `${line.credit.toFixed(2)} SEK` : "-";
+        console.log(`  Line ${line.line_number}: ${line.ledger_account_code} ${accountName ? `(${accountName})` : ""} | Debit: ${debit} | Credit: ${credit}`);
+    }
+    // Calculate total debits and credits across ALL lines (existing + new)
+    const allLinesForTotal = [
+        ...(entry.lines || []).map((l) => ({
+            line_number: l.lineNumber,
+            ledger_account_code: l.account,
+            debit: l.debit.amount,
+            credit: l.credit.amount,
+        })),
+        ...result.lines,
+    ];
+    const totals = calculateLineTotals(allLinesForTotal);
+    console.log("\nUpdating entry.yaml...");
+    await appendLinesToEntry(entryPath, result.lines, totals);
+    console.log(`✓ Successfully appended lines to ${entryPath} and updated totals`);
+    console.log(`  Total Debit: ${totals.totalDebit.toFixed(2)} SEK`);
+    console.log(`  Total Credit: ${totals.totalCredit.toFixed(2)} SEK`);
+    console.log(`  Balanced: ${totals.totalDebit === totals.totalCredit ? "✓" : "✗"}`);
+}

package/dist/commands/parse-pdf.js

@@ -0,0 +1,20 @@
+/**
+ * Extract text from a PDF file
+ */
+import pdf from "pdf-parse";
+import { readFile } from "node:fs/promises";
+export async function parsePdfCommand(options) {
+    const { file: filePath } = options;
+    try {
+        const buffer = await readFile(filePath);
+        const data = await pdf(buffer);
+        console.log(data.text);
+    }
+    catch (err) {
+        if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+            console.error(`Error: File not found: ${filePath}`);
+            process.exit(1);
+        }
+        throw err;
+    }
+}

package/dist/commands/sync-inbox.js

@@ -0,0 +1,186 @@
+import ora from "ora";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { toYaml, sanitizeOrgName } from "sync";
+import { loadConfig } from "../lib/env";
+import { createBokioClient } from "../lib/client";
+/**
+ * Slugify text for terminal-friendly filenames
+ */
+function slugify(text, maxLength = 30) {
+    return text
+        .toLowerCase()
+        .slice(0, maxLength)
+        .replace(/[^a-z0-9\s-]/g, "")
+        .replace(/\s+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "");
+}
+export async function syncInboxCommand() {
+    const cwd = process.cwd();
+    // Load config
+    const spinner = ora("Loading configuration...").start();
+    let config;
+    try {
+        config = loadConfig(cwd);
+        spinner.succeed(`Provider: ${config.provider}`);
+    }
+    catch (error) {
+        spinner.fail(error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+    }
+    // Create client
+    const client = createBokioClient(config);
+    // Validate connection
+    const validateSpinner = ora("Connecting to Bokio...").start();
+    try {
+        const companyInfo = await client.getCompanyInformation();
+        validateSpinner.succeed(`Connected to: ${companyInfo.name}`);
+    }
+    catch (error) {
+        validateSpinner.fail("Failed to connect to Bokio");
+        console.error(error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+    }
+    // Fetch uploads
+    const fetchSpinner = ora("Fetching inbox...").start();
+    const allUploads = [];
+    let page = 1;
+    const pageSize = 100;
+    while (true) {
+        const response = await client.getUploads({ page, pageSize });
+        allUploads.push(...response.data);
+        if (!response.pagination.hasNextPage)
+            break;
+        page++;
+    }
+    // Filter to unprocessed items (not linked to journal entry)
+    const unprocessedUploads = allUploads.filter((upload) => !upload.journalEntryId);
+    fetchSpinner.succeed(`Found ${unprocessedUploads.length} unprocessed inbox items (${allUploads.length} total)`);
+    if (unprocessedUploads.length === 0) {
+        console.log("\n  No new inbox items to download.\n");
+        return;
+    }
+    // Ensure inbox directory exists
+    const inboxDir = path.join(cwd, "inbox");
+    await fs.mkdir(inboxDir, { recursive: true });
+    // Download each unprocessed upload
+    let newCount = 0;
+    let existingCount = 0;
+    const today = new Date().toISOString().slice(0, 10);
+    // Track used directory names to handle duplicates
+    const usedDirNames = new Set();
+    // First, scan existing directories to avoid duplicates
+    try {
+        const existingDirs = await fs.readdir(inboxDir);
+        for (const dir of existingDirs) {
+            usedDirNames.add(dir);
+        }
+    }
+    catch {
+        // Inbox directory doesn't exist yet
+    }
+    for (const upload of unprocessedUploads) {
+        // Generate directory name: {date}-{description-slugified}
+        const slug = upload.description
+            ? slugify(upload.description)
+            : upload.id.slice(0, 8);
+        let dirName = `${today}-${slug}`;
+        // Check if this upload was already downloaded (by sourceId in existing document.yaml files)
+        const alreadyDownloaded = await isAlreadyDownloaded(inboxDir, upload.id);
+        if (alreadyDownloaded) {
+            existingCount++;
+            continue;
+        }
+        // Handle duplicate directory names by appending short ID
+        if (usedDirNames.has(dirName)) {
+            dirName = `${dirName}-${upload.id.slice(0, 8)}`;
+        }
+        usedDirNames.add(dirName);
+        const uploadDir = path.join(inboxDir, dirName);
+        process.stdout.write(`\r  Downloading: ${newCount + existingCount + 1}/${unprocessedUploads.length}`);
+        try {
+            // Create upload directory
+            await fs.mkdir(uploadDir, { recursive: true });
+            // Download file
+            const result = await client.downloadFile(upload.id);
+            // Determine file extension from content type
+            const ext = getExtensionFromContentType(upload.contentType || result.contentType);
+            // Generate filename: {description-slugified}.ext or document.ext
+            const filename = upload.description
+                ? `${slugify(upload.description)}${ext}`
+                : `document${ext}`;
+            // Save file
+            const filePath = path.join(uploadDir, filename);
+            const buffer = Buffer.from(result.data);
+            await fs.writeFile(filePath, buffer);
+            // Write document.yaml (ExportedInboxDocument format)
+            const document = {
+                kind: "OTHER",
+                status: "DRAFT",
+                fileName: filename,
+                mimeType: upload.contentType,
+                description: upload.description ?? undefined,
+                sourceIntegration: "bokio",
+                sourceId: upload.id,
+                uploadedAt: new Date().toISOString(),
+            };
+            const documentPath = path.join(uploadDir, "document.yaml");
+            await fs.writeFile(documentPath, toYaml(document));
+            newCount++;
+        }
+        catch (error) {
+            console.error(`\n  Failed to download ${upload.id}: ${error instanceof Error ? error.message : "Unknown error"}`);
+            // Clean up failed directory
+            try {
+                await fs.rm(uploadDir, { recursive: true });
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    }
+    console.log(`\n
+  Sync complete!
+    - ${newCount} new inbox items downloaded
+    - ${existingCount} already existed
+`);
+}
+function getExtensionFromContentType(contentType) {
+    const map = {
+        "application/pdf": ".pdf",
+        "image/jpeg": ".jpg",
+        "image/png": ".png",
+        "image/gif": ".gif",
+        "image/webp": ".webp",
+        "image/tiff": ".tiff",
+        "application/octet-stream": ".bin",
+    };
+    return map[contentType] || ".bin";
+}
+/**
+ * Check if an upload was already downloaded by scanning existing document.yaml files
+ */
+async function isAlreadyDownloaded(inboxDir, sourceId) {
+    try {
+        const dirs = await fs.readdir(inboxDir, { withFileTypes: true });
+        for (const dir of dirs) {
+            if (!dir.isDirectory())
+                continue;
+            const documentPath = path.join(inboxDir, dir.name, "document.yaml");
+            try {
+                const content = await fs.readFile(documentPath, "utf-8");
+                if (content.includes(`sourceId: ${sourceId}`)) {
+                    return true;
+                }
+            }
+            catch {
+                // document.yaml doesn't exist or can't be read, skip
+            }
+        }
+    }
+    catch {
+        // Inbox directory doesn't exist
+    }
+    return false;
+}