npm - @moatless/bookkeeping - Versions diffs - 0.1.0 - Mend

@moatless/bookkeeping 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (93) hide show

package/dist/accounting/index.d.ts +9 -0
package/dist/accounting/index.js +14 -0
package/dist/accounting/line-generator.d.ts +34 -0
package/dist/accounting/line-generator.js +136 -0
package/dist/accounting/tax-codes.d.ts +32 -0
package/dist/accounting/tax-codes.js +279 -0
package/dist/accounting/traktamente-rates.d.ts +48 -0
package/dist/accounting/traktamente-rates.js +325 -0
package/dist/accounting/types.d.ts +69 -0
package/dist/accounting/types.js +5 -0
package/dist/accounting/validation.d.ts +41 -0
package/dist/accounting/validation.js +118 -0
package/dist/auth/fortnox-login.d.ts +15 -0
package/dist/auth/fortnox-login.js +170 -0
package/dist/auth/index.d.ts +3 -0
package/dist/auth/index.js +3 -0
package/dist/auth/prompts.d.ts +6 -0
package/dist/auth/prompts.js +56 -0
package/dist/auth/token-store.d.ts +19 -0
package/dist/auth/token-store.js +54 -0
package/dist/index.d.ts +10 -0
package/dist/index.js +21 -0
package/dist/progress/index.d.ts +1 -0
package/dist/progress/index.js +1 -0
package/dist/progress/sync-progress.d.ts +31 -0
package/dist/progress/sync-progress.js +65 -0
package/dist/services/bokio-journal.d.ts +29 -0
package/dist/services/bokio-journal.js +175 -0
package/dist/services/document-download.d.ts +46 -0
package/dist/services/document-download.js +105 -0
package/dist/services/fortnox-inbox.d.ts +18 -0
package/dist/services/fortnox-inbox.js +150 -0
package/dist/services/fortnox-journal.d.ts +22 -0
package/dist/services/fortnox-journal.js +166 -0
package/dist/services/index.d.ts +6 -0
package/dist/services/index.js +6 -0
package/dist/services/journal-sync.d.ts +23 -0
package/dist/services/journal-sync.js +124 -0
package/dist/services/journal.service.d.ts +45 -0
package/dist/services/journal.service.js +204 -0
package/dist/storage/filesystem.d.ts +49 -0
package/dist/storage/filesystem.js +122 -0
package/dist/storage/index.d.ts +2 -0
package/dist/storage/index.js +1 -0
package/dist/storage/interface.d.ts +48 -0
package/dist/storage/interface.js +5 -0
package/dist/sync-types.d.ts +61 -0
package/dist/sync-types.js +1 -0
package/dist/transformers/bokio.d.ts +10 -0
package/dist/transformers/bokio.js +56 -0
package/dist/transformers/fortnox.d.ts +6 -0
package/dist/transformers/fortnox.js +39 -0
package/dist/transformers/index.d.ts +3 -0
package/dist/transformers/index.js +2 -0
package/dist/types/discarded-item.d.ts +29 -0
package/dist/types/discarded-item.js +1 -0
package/dist/types/document.d.ts +63 -0
package/dist/types/document.js +9 -0
package/dist/types/exported-document.d.ts +61 -0
package/dist/types/exported-document.js +9 -0
package/dist/types/exported-fiscal-year.d.ts +10 -0
package/dist/types/exported-fiscal-year.js +1 -0
package/dist/types/exported-inbox-document.d.ts +14 -0
package/dist/types/exported-inbox-document.js +10 -0
package/dist/types/fiscal-year.d.ts +10 -0
package/dist/types/fiscal-year.js +1 -0
package/dist/types/index.d.ts +10 -0
package/dist/types/index.js +10 -0
package/dist/types/journal-entry.d.ts +79 -0
package/dist/types/journal-entry.js +12 -0
package/dist/types/ledger-account.d.ts +5 -0
package/dist/types/ledger-account.js +1 -0
package/dist/utils/file-namer.d.ts +48 -0
package/dist/utils/file-namer.js +80 -0
package/dist/utils/git.d.ts +9 -0
package/dist/utils/git.js +41 -0
package/dist/utils/index.d.ts +6 -0
package/dist/utils/index.js +6 -0
package/dist/utils/paths.d.ts +17 -0
package/dist/utils/paths.js +24 -0
package/dist/utils/retry.d.ts +17 -0
package/dist/utils/retry.js +48 -0
package/dist/utils/templates.d.ts +12 -0
package/dist/utils/templates.js +222 -0
package/dist/utils/yaml.d.ts +12 -0
package/dist/utils/yaml.js +47 -0
package/dist/yaml/entry-helpers.d.ts +57 -0
package/dist/yaml/entry-helpers.js +125 -0
package/dist/yaml/index.d.ts +2 -0
package/dist/yaml/index.js +2 -0
package/dist/yaml/yaml-serializer.d.ts +21 -0
package/dist/yaml/yaml-serializer.js +60 -0
package/package.json +37 -0

package/dist/auth/fortnox-login.js ADDED Viewed

@@ -0,0 +1,170 @@
+import * as http from "node:http";
+import open from "open";
+import { buildAuthorizationUrl, exchangeCodeForToken, FORTNOX_SCOPES, } from "@moatless/fortnox-client";
+import { saveFortnoxToken, loadFortnoxToken, tokenExistsAt, } from "./token-store";
+import { promptForCredentials, promptConfirm } from "./prompts";
+const DEFAULT_PORT = 8585;
+const DEFAULT_SCOPES = [
+    FORTNOX_SCOPES.BOOKKEEPING,
+    FORTNOX_SCOPES.COMPANYINFORMATION,
+    FORTNOX_SCOPES.INBOX,
+    FORTNOX_SCOPES.ARCHIVE,
+    FORTNOX_SCOPES.CONNECTFILE,
+];
+const SUCCESS_HTML = `
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Authentication Complete</title>
+  <style>
+    body {
+      font-family: system-ui, sans-serif;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      height: 100vh;
+      margin: 0;
+      background: #fff;
+      color: #111;
+    }
+    .container { text-align: center; }
+    h1 { font-size: 1.5rem; margin-bottom: 0.5rem; }
+    p { color: #666; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>&#10003; Authentication complete</h1>
+    <p>You can close this window.</p>
+  </div>
+</body>
+</html>
+`;
+const ERROR_HTML = (error) => `
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Authentication Failed</title>
+  <style>
+    body {
+      font-family: system-ui, sans-serif;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      height: 100vh;
+      margin: 0;
+      background: #fff;
+      color: #111;
+    }
+    .container { text-align: center; }
+    h1 { font-size: 1.5rem; margin-bottom: 0.5rem; color: #c00; }
+    p { color: #666; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>Authentication failed</h1>
+    <p>${error}</p>
+  </div>
+</body>
+</html>
+`;
+async function startCallbackServer(port) {
+    let resolveCallback;
+    const resultPromise = new Promise((resolve) => {
+        resolveCallback = resolve;
+    });
+    const server = http.createServer((req, res) => {
+        const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+        if (url.pathname === "/callback") {
+            const code = url.searchParams.get("code");
+            const error = url.searchParams.get("error");
+            const errorDescription = url.searchParams.get("error_description");
+            res.setHeader("Content-Type", "text/html");
+            if (error) {
+                resolveCallback({ error, errorDescription: errorDescription ?? undefined });
+                res.statusCode = 200;
+                res.end(ERROR_HTML(errorDescription ?? error));
+                return;
+            }
+            if (code) {
+                resolveCallback({ code });
+                res.statusCode = 200;
+                res.end(SUCCESS_HTML);
+                return;
+            }
+            resolveCallback({ error: "No authorization code received" });
+            res.statusCode = 200;
+            res.end(ERROR_HTML("No authorization code received"));
+            return;
+        }
+        res.statusCode = 404;
+        res.end("Not found");
+    });
+    await new Promise((resolve) => {
+        server.listen(port, () => resolve());
+    });
+    return {
+        result: resultPromise,
+        stop: () => server.close(),
+    };
+}
+export async function loginFortnox(options) {
+    const { cwd, scopes = DEFAULT_SCOPES, port = DEFAULT_PORT, force = false, onStatus = console.log, } = options;
+    // Check for existing token
+    if (!force && tokenExistsAt(cwd)) {
+        const existingToken = loadFortnoxToken(cwd);
+        if (existingToken) {
+            const overwrite = await promptConfirm("Fortnox token already exists. Overwrite?");
+            if (!overwrite) {
+                onStatus("Login cancelled.");
+                return existingToken;
+            }
+        }
+    }
+    // Get credentials
+    let clientId = options.clientId;
+    let clientSecret = options.clientSecret;
+    if (!clientId || !clientSecret) {
+        const credentials = await promptForCredentials();
+        clientId = credentials.clientId;
+        clientSecret = credentials.clientSecret;
+    }
+    const redirectUri = `http://localhost:${port}/callback`;
+    const config = {
+        clientId,
+        clientSecret,
+        redirectUri,
+        scopes,
+    };
+    // Start callback server
+    onStatus(`Starting OAuth callback server on port ${port}...`);
+    const { result, stop } = await startCallbackServer(port);
+    try {
+        // Build auth URL and open browser
+        const state = crypto.randomUUID();
+        const authUrl = buildAuthorizationUrl(config, state);
+        onStatus("Opening browser for Fortnox authorization...");
+        await open(authUrl);
+        onStatus("Waiting for authorization (press Ctrl+C to cancel)...");
+        // Wait for callback
+        const callbackResult = await result;
+        if (callbackResult.error) {
+            throw new Error(callbackResult.errorDescription ?? callbackResult.error);
+        }
+        if (!callbackResult.code) {
+            throw new Error("No authorization code received");
+        }
+        // Exchange code for token
+        onStatus("Exchanging authorization code for token...");
+        const tokenResponse = await exchangeCodeForToken(config, callbackResult.code);
+        // Save token
+        const storedToken = saveFortnoxToken(cwd, tokenResponse);
+        onStatus("Token saved to .kvitton/tokens/fortnox.json");
+        return storedToken;
+    }
+    finally {
+        stop();
+    }
+}
+export { DEFAULT_SCOPES as FORTNOX_DEFAULT_SCOPES };

package/dist/auth/index.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+export { loginFortnox, FORTNOX_DEFAULT_SCOPES, type LoginOptions, } from "./fortnox-login";
+export { saveFortnoxToken, loadFortnoxToken, deleteFortnoxToken, isTokenExpired, tokenExistsAt, type StoredFortnoxToken, type FortnoxTokenResponse, } from "./token-store";
+export { promptForCredentials, promptConfirm, promptInput, } from "./prompts";

package/dist/auth/index.js ADDED Viewed

@@ -0,0 +1,3 @@
+export { loginFortnox, FORTNOX_DEFAULT_SCOPES, } from "./fortnox-login";
+export { saveFortnoxToken, loadFortnoxToken, deleteFortnoxToken, isTokenExpired, tokenExistsAt, } from "./token-store";
+export { promptForCredentials, promptConfirm, promptInput, } from "./prompts";

package/dist/auth/prompts.d.ts ADDED Viewed

@@ -0,0 +1,6 @@
+export declare function promptForCredentials(): Promise<{
+    clientId: string;
+    clientSecret: string;
+}>;
+export declare function promptConfirm(message: string): Promise<boolean>;
+export declare function promptInput(message: string): Promise<string>;

package/dist/auth/prompts.js ADDED Viewed

@@ -0,0 +1,56 @@
+import * as readline from "node:readline";
+function createInterface() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+}
+function question(rl, prompt) {
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            resolve(answer);
+        });
+    });
+}
+export async function promptForCredentials() {
+    const rl = createInterface();
+    try {
+        console.log("\nFortnox OAuth credentials required.");
+        console.log("Get these from: https://developer.fortnox.se/my-apps\n");
+        const clientId = await question(rl, "FORTNOX_CLIENT_ID: ");
+        if (!clientId.trim()) {
+            throw new Error("Client ID is required");
+        }
+        const clientSecret = await question(rl, "FORTNOX_CLIENT_SECRET: ");
+        if (!clientSecret.trim()) {
+            throw new Error("Client Secret is required");
+        }
+        return {
+            clientId: clientId.trim(),
+            clientSecret: clientSecret.trim(),
+        };
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function promptConfirm(message) {
+    const rl = createInterface();
+    try {
+        const answer = await question(rl, `${message} (y/N): `);
+        return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function promptInput(message) {
+    const rl = createInterface();
+    try {
+        const answer = await question(rl, `${message}: `);
+        return answer.trim();
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/auth/token-store.d.ts ADDED Viewed

@@ -0,0 +1,19 @@
+export interface StoredFortnoxToken {
+    access_token: string;
+    refresh_token: string;
+    scope: string;
+    expires_at: string;
+    created_at: string;
+}
+export interface FortnoxTokenResponse {
+    access_token: string;
+    refresh_token: string;
+    scope: string;
+    expires_in: number;
+    token_type: "bearer";
+}
+export declare function saveFortnoxToken(cwd: string, token: FortnoxTokenResponse): StoredFortnoxToken;
+export declare function loadFortnoxToken(cwd: string): StoredFortnoxToken | null;
+export declare function deleteFortnoxToken(cwd: string): void;
+export declare function isTokenExpired(token: StoredFortnoxToken): boolean;
+export declare function tokenExistsAt(cwd: string): boolean;

package/dist/auth/token-store.js ADDED Viewed

@@ -0,0 +1,54 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getTokensDir } from "../utils/paths";
+const FORTNOX_TOKEN_FILE = "fortnox.json";
+function getTokenPath(cwd) {
+    return path.join(getTokensDir(cwd), FORTNOX_TOKEN_FILE);
+}
+function ensureTokenDir(cwd) {
+    const dir = getTokensDir(cwd);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+export function saveFortnoxToken(cwd, token) {
+    ensureTokenDir(cwd);
+    const expiresAt = new Date(Date.now() + token.expires_in * 1000);
+    const stored = {
+        access_token: token.access_token,
+        refresh_token: token.refresh_token,
+        scope: token.scope,
+        expires_at: expiresAt.toISOString(),
+        created_at: new Date().toISOString(),
+    };
+    fs.writeFileSync(getTokenPath(cwd), JSON.stringify(stored, null, 2), "utf-8");
+    return stored;
+}
+export function loadFortnoxToken(cwd) {
+    const tokenPath = getTokenPath(cwd);
+    if (!fs.existsSync(tokenPath)) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(tokenPath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export function deleteFortnoxToken(cwd) {
+    const tokenPath = getTokenPath(cwd);
+    if (fs.existsSync(tokenPath)) {
+        fs.unlinkSync(tokenPath);
+    }
+}
+export function isTokenExpired(token) {
+    const expiresAt = new Date(token.expires_at);
+    // Consider token expired 5 minutes before actual expiry for safety
+    const safetyMargin = 5 * 60 * 1000;
+    return expiresAt.getTime() - safetyMargin <= Date.now();
+}
+export function tokenExistsAt(cwd) {
+    return fs.existsSync(getTokenPath(cwd));
+}

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+export * from "./types";
+export * from "./sync-types";
+export * from "./accounting";
+export { readEntryYaml, readDocumentsYaml, readDocumentYaml, writeEntryYaml, appendLinesToEntry, readAccountsYaml, validateAccountExists, getAccountName, } from "./yaml";
+export * from "./transformers";
+export * from "./storage";
+export * from "./utils";
+export * from "./services";
+export * from "./auth";
+export * from "./progress";

package/dist/index.js ADDED Viewed

@@ -0,0 +1,21 @@
+// Types (journal entries, documents, fiscal years, etc.)
+export * from "./types";
+// Sync types (sync stats, errors, results)
+export * from "./sync-types";
+// Accounting logic
+export * from "./accounting";
+// YAML utilities (from yaml module - entry helpers, etc.)
+// Note: parseYaml and toYaml are also exported from ./utils
+export { readEntryYaml, readDocumentsYaml, readDocumentYaml, writeEntryYaml, appendLinesToEntry, readAccountsYaml, validateAccountExists, getAccountName, } from "./yaml";
+// Transformers
+export * from "./transformers";
+// Storage
+export * from "./storage";
+// Utils (includes parseYaml, toYaml)
+export * from "./utils";
+// Services
+export * from "./services";
+// Auth utilities
+export * from "./auth";
+// Progress bar utilities
+export * from "./progress";

package/dist/progress/index.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export { SyncProgressBar, type SyncProgress, type FiscalYearSummary, } from "./sync-progress";

package/dist/progress/index.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export { SyncProgressBar, } from "./sync-progress";

package/dist/progress/sync-progress.d.ts ADDED Viewed

@@ -0,0 +1,31 @@
+export interface SyncProgress {
+    current: number;
+    total: number;
+    message?: string;
+    /** Phase of sync: discovering (listing) or fetching (getting details) */
+    phase?: "discovering" | "fetching";
+}
+export interface FiscalYearSummary {
+    id: number;
+    year: number;
+    fromDate: string;
+    toDate: string;
+    entryCount: number;
+}
+export declare class SyncProgressBar {
+    private bar;
+    private currentPhase;
+    private started;
+    constructor();
+    start(total: number, phase?: string): void;
+    update(current: number, phase?: string): void;
+    stop(): void;
+    /**
+     * Create an adapter for the existing SyncProgress callback pattern.
+     * Handles both discovery phase (no bar, just count) and fetching phase (progress bar).
+     */
+    static createCallback(): {
+        bar: SyncProgressBar;
+        onProgress: (progress: SyncProgress) => void;
+    };
+}

package/dist/progress/sync-progress.js ADDED Viewed

@@ -0,0 +1,65 @@
+import cliProgress from "cli-progress";
+export class SyncProgressBar {
+    bar;
+    currentPhase = "";
+    started = false;
+    constructor() {
+        this.bar = new cliProgress.SingleBar({
+            format: "  {phase} [{bar}] {percentage}% | {value}/{total}",
+            barCompleteChar: "\u2588",
+            barIncompleteChar: "\u2591",
+            barsize: 20,
+            hideCursor: true,
+            clearOnComplete: false,
+        });
+    }
+    start(total, phase) {
+        this.currentPhase = phase ?? "Syncing...";
+        this.started = true;
+        this.bar.start(total, 0, { phase: this.currentPhase });
+    }
+    update(current, phase) {
+        if (phase && phase !== this.currentPhase) {
+            this.currentPhase = phase;
+        }
+        this.bar.update(current, { phase: this.currentPhase });
+    }
+    stop() {
+        if (this.started) {
+            this.bar.stop();
+            this.started = false;
+        }
+    }
+    /**
+     * Create an adapter for the existing SyncProgress callback pattern.
+     * Handles both discovery phase (no bar, just count) and fetching phase (progress bar).
+     */
+    static createCallback() {
+        const bar = new SyncProgressBar();
+        let barStarted = false;
+        let discoveryShown = false;
+        return {
+            bar,
+            onProgress: (progress) => {
+                if (progress.phase === "discovering") {
+                    // Discovery phase - show count without bar (total unknown)
+                    process.stdout.write(`\r  ${progress.message ?? "Discovering..."} ${progress.current.toLocaleString()} found`);
+                    discoveryShown = true;
+                }
+                else {
+                    // Fetching phase - show progress bar
+                    if (!barStarted && progress.total > 0) {
+                        if (discoveryShown) {
+                            console.log(); // Newline after discovery
+                        }
+                        bar.start(progress.total, progress.message);
+                        barStarted = true;
+                    }
+                    if (barStarted) {
+                        bar.update(progress.current, progress.message);
+                    }
+                }
+            },
+        };
+    }
+}

package/dist/services/bokio-journal.d.ts ADDED Viewed

@@ -0,0 +1,29 @@
+import type { BokioClient } from "@moatless/bokio-client";
+import type { FilesystemStorageService } from "../storage/filesystem";
+export interface BokioSyncProgress {
+    current: number;
+    total: number;
+    message?: string;
+}
+export interface BokioJournalSyncOptions {
+    downloadFiles?: boolean;
+    targetYear?: number;
+    onProgress?: (progress: BokioSyncProgress) => void;
+}
+export interface BokioJournalSyncResult {
+    entriesCount: number;
+    newEntries: number;
+    existingEntries: number;
+    fiscalYearsCount: number;
+    entriesWithFilesDownloaded: number;
+}
+/**
+ * Sync journal entries from Bokio
+ */
+export declare function syncBokioJournalEntries(client: BokioClient, storage: FilesystemStorageService, options?: BokioJournalSyncOptions): Promise<BokioJournalSyncResult>;
+/**
+ * Sync chart of accounts from Bokio to accounts.yaml
+ */
+export declare function syncBokioChartOfAccounts(client: BokioClient, storage: FilesystemStorageService): Promise<{
+    accountsCount: number;
+}>;

package/dist/services/bokio-journal.js ADDED Viewed

@@ -0,0 +1,175 @@
+import { fiscalYearDirName } from "../utils/file-namer";
+import { toYaml } from "../utils/yaml";
+import { mapBokioEntryToJournalEntry } from "../transformers";
+import { downloadFilesForEntry } from "./document-download";
+import { JournalService } from "./journal.service";
+/**
+ * Create a FileDownloader adapter for BokioClient
+ */
+function createBokioDownloader(client) {
+    return {
+        async getFilesForEntry(journalEntryId) {
+            const response = await client.getUploads({
+                query: `journalEntryId==${journalEntryId}`,
+            });
+            return response.data.map((upload) => ({
+                id: upload.id,
+                contentType: upload.contentType,
+                description: upload.description ?? undefined,
+            }));
+        },
+        async downloadFile(id) {
+            return client.downloadFile(id);
+        },
+    };
+}
+function findFiscalYear(date, fiscalYears) {
+    return fiscalYears.find((fy) => date >= fy.startDate && date <= fy.endDate);
+}
+/**
+ * Sync journal entries from Bokio
+ */
+export async function syncBokioJournalEntries(client, storage, options = {}) {
+    const { downloadFiles = false, targetYear, onProgress = () => { } } = options;
+    const journalService = new JournalService(storage);
+    // 1. Fetch fiscal years
+    const fiscalYearsResponse = await client.getFiscalYears();
+    const allFiscalYears = fiscalYearsResponse.data;
+    // Filter fiscal years if targeting a specific year
+    const fiscalYears = targetYear
+        ? allFiscalYears.filter((fy) => parseInt(fy.startDate.slice(0, 4), 10) === targetYear)
+        : allFiscalYears;
+    if (targetYear && fiscalYears.length === 0) {
+        return {
+            entriesCount: 0,
+            newEntries: 0,
+            existingEntries: 0,
+            fiscalYearsCount: 0,
+            entriesWithFilesDownloaded: 0,
+        };
+    }
+    // 2. Fetch total count first for progress display
+    const firstPage = await client.getJournalEntries({ page: 1, pageSize: 1 });
+    const totalFromApi = firstPage.pagination.totalItems;
+    onProgress({ current: 0, total: totalFromApi, message: "Starting sync..." });
+    if (totalFromApi === 0) {
+        await writeBokioFiscalYearsMetadata(storage, fiscalYears);
+        return {
+            entriesCount: 0,
+            newEntries: 0,
+            existingEntries: 0,
+            fiscalYearsCount: fiscalYears.length,
+            entriesWithFilesDownloaded: 0,
+        };
+    }
+    // 3. Fetch all entries with pagination
+    const allEntries = [];
+    let page = 1;
+    const pageSize = 100;
+    while (true) {
+        const response = await client.getJournalEntries({ page, pageSize });
+        allEntries.push(...response.data);
+        onProgress({ current: allEntries.length, total: totalFromApi });
+        if (!response.pagination.hasNextPage)
+            break;
+        page++;
+    }
+    // 4. Filter entries by target fiscal year(s)
+    const entriesToSync = targetYear
+        ? allEntries.filter((entry) => {
+            const fy = findFiscalYear(entry.date, fiscalYears);
+            return fy !== undefined;
+        })
+        : allEntries;
+    const existingEntriesByYear = new Map();
+    for (const fy of fiscalYears) {
+        const fyYear = parseInt(fy.startDate.slice(0, 4), 10);
+        const existingRecords = await journalService.listJournalEntryRecords(fyYear);
+        existingEntriesByYear.set(fyYear, existingRecords);
+    }
+    // 5. Write all entries first (so entries are synced even if file downloads fail)
+    let newEntries = 0;
+    let existingEntries = 0;
+    const entryDirs = new Map();
+    for (const entry of entriesToSync) {
+        const fiscalYear = findFiscalYear(entry.date, allFiscalYears);
+        if (!fiscalYear)
+            continue;
+        const fyYear = parseInt(fiscalYear.startDate.slice(0, 4), 10);
+        const journalEntry = mapBokioEntryToJournalEntry(entry);
+        const entryKey = journalEntry.externalId ??
+            `${journalEntry.series ?? ""}-${journalEntry.entryNumber}`;
+        const existingRecords = existingEntriesByYear.get(fyYear);
+        const existingRecord = existingRecords?.get(entryKey);
+        const result = await journalService.upsertJournalEntry(fyYear, journalEntry, existingRecord);
+        if (result.action === "created") {
+            newEntries++;
+        }
+        else {
+            existingEntries++;
+        }
+        entryDirs.set(entry.id, result.entryDir);
+    }
+    // 6. Write fiscal year metadata
+    await writeBokioFiscalYearsMetadata(storage, fiscalYears);
+    // 7. Download files for entries (if enabled)
+    let entriesWithFilesDownloaded = 0;
+    if (downloadFiles) {
+        const downloader = createBokioDownloader(client);
+        for (const entry of entriesToSync) {
+            const entryDir = entryDirs.get(entry.id);
+            if (!entryDir)
+                continue;
+            const filesDownloaded = await downloadFilesForEntry({
+                storage,
+                repoPath: "",
+                entryDir,
+                journalEntryId: entry.id,
+                downloader,
+                sourceIntegration: "bokio",
+            });
+            if (filesDownloaded > 0) {
+                entriesWithFilesDownloaded++;
+            }
+        }
+    }
+    return {
+        entriesCount: entriesToSync.length,
+        newEntries,
+        existingEntries,
+        fiscalYearsCount: fiscalYears.length,
+        entriesWithFilesDownloaded,
+    };
+}
+async function writeBokioFiscalYearsMetadata(storage, fiscalYears) {
+    for (const fy of fiscalYears) {
+        const fyDir = fiscalYearDirName({ start_date: fy.startDate });
+        const metadataPath = `journal-entries/${fyDir}/_fiscal-year.yaml`;
+        const metadata = {
+            id: fy.id,
+            startDate: fy.startDate,
+            endDate: fy.endDate,
+            status: fy.status,
+        };
+        const yamlContent = toYaml(metadata);
+        await storage.writeFile(metadataPath, yamlContent);
+    }
+}
+/**
+ * Sync chart of accounts from Bokio to accounts.yaml
+ */
+export async function syncBokioChartOfAccounts(client, storage) {
+    const bokioAccounts = await client.getChartOfAccounts();
+    // Sort by account number and transform to expected format
+    const accounts = [...bokioAccounts]
+        .sort((a, b) => a.account - b.account)
+        .map((account) => ({
+        code: account.account.toString(),
+        name: account.name,
+        description: account.name,
+    }));
+    // Write accounts.yaml
+    const yamlContent = toYaml({ accounts });
+    await storage.writeFile("accounts.yaml", yamlContent);
+    return { accountsCount: accounts.length };
+}