feat(bank-sync): close the F2 report: gap backfill, consent and paused chip states, agent-triggered sync (#2165)
* fix(bank-sync): cron backfills the gap since the last successful sync The daily incremental sync always asked the bank for the last 7 days. Any pause longer than that (a lapsed subscription paid again, a consent renewed after expiry, an outage) silently lost the days in between: the connection came back, looked healthy, and the missing transactions never arrived. The lookback now widens to cover the gap since last_synced_at plus one day of overlap, capped at the 90-day PSD2 limit, and a gap of a month or more asks for strategy=longest like the manual sync route does. Dedup via external_id makes the overlap harmless. First syncs keep their 90-day path. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01QdcDV7CngLkWUvfKSsxFhS * feat(bank-sync): chip warns seven days before a bank consent expires The transactions-page chip only reacted once a connection was already dead (expired/error) or had gone stale. A consent that is about to end looked healthy until the morning it stopped syncing. New "expiring" state when a live connection's consent_expires is within seven days, the same threshold as the consent-expiry email in the sync cron. Precedence: attention, expiring, stale, healthy. getChipState moves to lib/transactions/bank-sync-chip-state.ts so the precedence is unit-tested; the component keeps the rendering only. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01QdcDV7CngLkWUvfKSsxFhS * feat(bank-sync): chip says paused when the subscription lapsed The daily cron filters connections by the bank_sync capability, so a company whose trial or subscription ended keeps status=active rows with a frozen last_synced_at. The chip read that as "stale, check the connection", which sends the user to re-authorise a connection that is perfectly alive. 56 of 191 active connections on prod were in this state on 2026-09-01. New "paused" state, ranked above everything else, when the company lacks bank_sync: hosted points at billing, self-host at the connector key, the same split BankSyncNowButton already makes. getChipState takes an options object so the clock stays out of render (react-hooks/purity). Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01QdcDV7CngLkWUvfKSsxFhS * feat(api): agent-triggerable bank sync in v1 and MCP Closes the first wish in the F2 report: an integration could read bank data but never refresh it. New POST /api/v1/companies/{id}/bank-connections/ {connectionId}/sync and MCP gnubok_sync_bank, both on a shared runner (extensions/general/enable-banking/lib/trigger-sync.ts). Cost is bounded structurally, not by policy: the window is never caller-controlled (the cron's gap-aware 7 to 90 day lookback), a connection synced within 15 minutes answers BANK_SYNC_COOLDOWN with next_allowed_at (429 + Retry-After on v1; synced=false in-band on MCP so the agent reads on instead of retrying), and a failing connection is throttled per process by attempt time. A dead session is flipped to expired with a remediation that hands the user the connect link: no API call revives a consent. Gated on bank_sync like gnubok_connect_bank; scope transactions:write. Registry, scope map, load-routes, spec snapshot and the generated accounted-api skill updated; five BANK_SYNC_* / BANK_SESSION_EXPIRED codes added to the structured-error registry. The web Synka-nu route is left as is (see DECISIONS.md). Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01QdcDV7CngLkWUvfKSsxFhS * test(bank-sync): use the options object in the remaining chip-state calls Four multi-line calls still passed the clock positionally after getChipState moved to an options object; tsc flagged them (vitest did not, the extra argument was ignored at runtime). Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01QdcDV7CngLkWUvfKSsxFhS * fix(api): address skeptic findings on the agent-triggered bank sync Three refutations from the pre-publish skeptic pass: 1. Core imported the extension. The v1 sync route pulled the runner straight from @/extensions, which the core-build gate rejects and which left a live bank endpoint on zero-extension builds. The route now resolves it through the registry's services channel against a contract in lib/bank-sync/trigger-sync-contract.ts (same pattern as the Skatteverket read service) and answers EXTENSION_DISABLED when the extension is absent. 2. The idempotency cache stored the handler-level 429. A same-key retry after Retry-After, which is the documented retry, replayed the stale cooldown as a 400 for the cache's 24-hour TTL. withApiV1 no longer caches 429 responses; regression test added. The endpoint's pitfall no longer claims Idempotency-Key is mandatory (it was never enforced). 3. Two cron tests read the clock twice and failed whenever a millisecond passed between the reads. They now pin the clock with fake timers. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01QdcDV7CngLkWUvfKSsxFhS * fix(bank-sync): durable cooldown lease and review wording Resolves the PR #2165 review findings in one pass. Superagent P1: the attempt throttle was a process-local Map, so two agent calls on different serverless instances (or a retry after a cold start on a failing connection) could each bill an Enable Banking call, contradicting the one-sync-per-15-minutes promise. New bank_connections.sync_lease_until (migration 20260902150000), claimed with one conditional UPDATE before the bank is called; Postgres row locking makes exactly one claimer win, the rest answer BANK_SYNC_COOLDOWN. The lease stays for the full window on success and failure. Tests cover the claim order, a failed attempt seen from a second instance, a lost race, and an expired lease. CodeRabbit: the =1 plural branch now reads "in 1 day" / "om 1 dag" (daysUntilConsentExpiry rounds a partial day up, so "tomorrow" could be today); the cooldown pitfall on the v1 endpoint, the MCP description and the in-band cooldown instruction now say a cooldown can follow a failed attempt and tell the agent to compare last_synced_at before deciding. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_0125TMQQBjBBZG9YxP7wQWub * fix(bank-sync): lease claim as a literal filter for the schema guard CI's no-phantom-columns guard counts runtime-built query expressions and its ceiling is exact; the templated `.or('sync_lease_until.is.null,...')` claim added one. The column now defaults to epoch (NOT NULL), so "never claimed" is just "expired long ago" and the atomic claim is a single literal `.lte('sync_lease_until', now)` the guard can check. Migration is unshipped (same PR), so it is edited in place. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_0125TMQQBjBBZG9YxP7wQWub * fix(bank-sync): runner verifies company membership before the lease Superagent (round 3): the MCP path reached the shared runner without a membership check of its own. Both callers do enforce it upstream (withApiV1's company resolution and resolveMcpCompanyContext in the MCP dispatcher), but the runner writes transactions and bills a bank call, so it now checks company_members itself, before the cooldown and the lease claim, and answers NOT_FOUND for a non-member. The viewer check that was buried inside the sync block moves up with it. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_0125TMQQBjBBZG9YxP7wQWub --------- Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
Mattsson
co-authored by
Claude Fable 5.1
Claude Fable 5.1
parent
723a0f537b
commit
b68c082ef5
@@ -12,6 +12,7 @@ import {
|
||||
type ASPSP,
|
||||
} from './lib/api-client'
|
||||
import { syncAccountTransactions } from './lib/sync'
|
||||
import { triggerConnectionSync } from './lib/trigger-sync'
|
||||
import { findReusableSessions, countLiveSiblings } from './lib/session-sharing'
|
||||
import {
|
||||
runUnattendedReconciliationSweep,
|
||||
@@ -62,6 +63,13 @@ export const enableBankingExtension: Extension = {
|
||||
path: '/settings/banking',
|
||||
},
|
||||
|
||||
// Registry-resolved services for core callers (core cannot import
|
||||
// @/extensions). Contract: lib/bank-sync/trigger-sync-contract.ts.
|
||||
services: {
|
||||
// Agent-triggered sync behind POST /api/v1/.../bank-connections/{id}/sync.
|
||||
triggerConnectionSync,
|
||||
},
|
||||
|
||||
apiRoutes: [
|
||||
{
|
||||
method: 'GET',
|
||||
|
||||
@@ -0,0 +1,37 @@
|
||||
import { describe, expect, it } from 'vitest'
|
||||
import { incrementalLookbackDays } from '../cron-lookback'
|
||||
|
||||
const NOW = Date.parse('2026-09-02T05:00:00Z')
|
||||
const daysAgo = (d: number) => new Date(NOW - d * 24 * 60 * 60 * 1000).toISOString()
|
||||
|
||||
describe('incrementalLookbackDays', () => {
|
||||
it('keeps the 7-day window when the last sync is recent', () => {
|
||||
expect(incrementalLookbackDays(daysAgo(0), NOW)).toBe(7)
|
||||
expect(incrementalLookbackDays(daysAgo(1), NOW)).toBe(7)
|
||||
expect(incrementalLookbackDays(daysAgo(5), NOW)).toBe(7)
|
||||
})
|
||||
|
||||
it('widens the window to cover a gap, with one day of overlap', () => {
|
||||
expect(incrementalLookbackDays(daysAgo(7), NOW)).toBe(8)
|
||||
expect(incrementalLookbackDays(daysAgo(20), NOW)).toBe(21)
|
||||
})
|
||||
|
||||
it('rounds a partial day up so the gap is never under-covered', () => {
|
||||
expect(incrementalLookbackDays(daysAgo(10.4), NOW)).toBe(12)
|
||||
})
|
||||
|
||||
it('caps at the 90-day PSD2 limit', () => {
|
||||
expect(incrementalLookbackDays(daysAgo(200), NOW)).toBe(90)
|
||||
expect(incrementalLookbackDays(daysAgo(89), NOW)).toBe(90)
|
||||
})
|
||||
|
||||
it('falls back to 7 days when there is no usable timestamp', () => {
|
||||
expect(incrementalLookbackDays(null, NOW)).toBe(7)
|
||||
expect(incrementalLookbackDays(undefined, NOW)).toBe(7)
|
||||
expect(incrementalLookbackDays('not a date', NOW)).toBe(7)
|
||||
})
|
||||
|
||||
it('never goes below 7 days for a future timestamp (clock skew)', () => {
|
||||
expect(incrementalLookbackDays(daysAgo(-2), NOW)).toBe(7)
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,269 @@
|
||||
import { beforeEach, describe, expect, it, vi } from 'vitest'
|
||||
|
||||
const mocks = vi.hoisted(() => ({
|
||||
syncAccountTransactions: vi.fn(),
|
||||
updateBalancesFromSync: vi.fn(),
|
||||
emit: vi.fn(),
|
||||
}))
|
||||
|
||||
vi.mock('../sync', () => ({
|
||||
syncAccountTransactions: (...args: unknown[]) => mocks.syncAccountTransactions(...args),
|
||||
}))
|
||||
vi.mock('@/lib/cash-accounts/service', () => ({
|
||||
updateBalancesFromSync: (...args: unknown[]) => mocks.updateBalancesFromSync(...args),
|
||||
}))
|
||||
vi.mock('@/lib/events/bus', () => ({
|
||||
eventBus: { emit: (...args: unknown[]) => mocks.emit(...args) },
|
||||
}))
|
||||
|
||||
import { SessionExpiredError, REAUTH_REQUIRED_MESSAGE } from '../api-client'
|
||||
import { SYNC_COOLDOWN_MS, triggerConnectionSync } from '../trigger-sync'
|
||||
|
||||
const COMPANY_ID = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa'
|
||||
const CONNECTION_ID = '11111111-1111-4111-8111-111111111111'
|
||||
const NOW = Date.parse('2026-09-02T09:00:00Z')
|
||||
const DAY_MS = 24 * 60 * 60 * 1000
|
||||
|
||||
interface State {
|
||||
connection: Record<string, unknown> | null
|
||||
membershipRole: string | null
|
||||
sieOverlap: boolean
|
||||
updates: Record<string, unknown>[]
|
||||
/**
|
||||
* The durable lease as the database holds it (epoch when never claimed).
|
||||
* The conditional UPDATE the runner issues (`sync_lease_until <= now`) is
|
||||
* reproduced here: a held lease makes the claim return no row.
|
||||
*/
|
||||
leaseUntil: string
|
||||
}
|
||||
|
||||
const EPOCH = '1970-01-01T00:00:00.000Z'
|
||||
|
||||
function makeClient(state: State) {
|
||||
return {
|
||||
from: (table: string) => {
|
||||
let updatePayload: Record<string, unknown> | null = null
|
||||
let lteFilter: { column: string; value: string } | null = null
|
||||
const chain: Record<string, unknown> = {}
|
||||
const passthrough = ['select', 'eq', 'gte', 'order', 'limit', 'in']
|
||||
for (const m of passthrough) chain[m] = vi.fn(() => chain)
|
||||
chain.lte = vi.fn((column: string, value: string) => {
|
||||
lteFilter = { column, value }
|
||||
return chain
|
||||
})
|
||||
chain.update = vi.fn((payload: Record<string, unknown>) => {
|
||||
updatePayload = payload
|
||||
return chain
|
||||
})
|
||||
const resolve = () => {
|
||||
if (updatePayload && 'sync_lease_until' in updatePayload) {
|
||||
// Atomic claim: `.lte('sync_lease_until', <now>)`.
|
||||
if (lteFilter?.column !== 'sync_lease_until') {
|
||||
throw new Error('lease claim must carry the conditional filter')
|
||||
}
|
||||
if (state.leaseUntil > lteFilter.value) return { data: [], error: null }
|
||||
state.leaseUntil = updatePayload.sync_lease_until as string
|
||||
state.updates.push(updatePayload)
|
||||
return { data: [{ id: CONNECTION_ID }], error: null }
|
||||
}
|
||||
if (updatePayload) {
|
||||
state.updates.push(updatePayload)
|
||||
return { data: null, error: null }
|
||||
}
|
||||
if (table === 'bank_connections') return { data: state.connection, error: null }
|
||||
if (table === 'company_members')
|
||||
return { data: state.membershipRole ? { role: state.membershipRole } : null, error: null }
|
||||
if (table === 'sie_imports') return { data: state.sieOverlap ? { id: 'sie-1' } : null, error: null }
|
||||
if (table === 'transactions') return { data: [{ id: 'tx-1' }], error: null }
|
||||
return { data: null, error: null }
|
||||
}
|
||||
chain.maybeSingle = vi.fn(() => Promise.resolve(resolve()))
|
||||
chain.then = (onFulfilled: (v: unknown) => unknown) => Promise.resolve(resolve()).then(onFulfilled)
|
||||
return chain
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
function connection(overrides: Record<string, unknown> = {}) {
|
||||
return {
|
||||
id: CONNECTION_ID,
|
||||
company_id: COMPANY_ID,
|
||||
bank_name: 'Swedbank',
|
||||
status: 'active',
|
||||
accounts_data: [
|
||||
{ uid: 'acc-1', currency: 'SEK', enabled: true, balance: 100 },
|
||||
{ uid: 'acc-2', currency: 'SEK', enabled: false, balance: 5 },
|
||||
],
|
||||
last_synced_at: new Date(NOW - 2 * DAY_MS).toISOString(),
|
||||
error_message: null,
|
||||
sync_lease_until: EPOCH,
|
||||
...overrides,
|
||||
}
|
||||
}
|
||||
|
||||
const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn() }
|
||||
let state: State
|
||||
|
||||
function run(now = NOW) {
|
||||
return triggerConnectionSync(makeClient(state) as never, {
|
||||
companyId: COMPANY_ID,
|
||||
userId: 'user-1',
|
||||
connectionId: CONNECTION_ID,
|
||||
log,
|
||||
now,
|
||||
})
|
||||
}
|
||||
|
||||
describe('triggerConnectionSync', () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks()
|
||||
state = {
|
||||
connection: connection(),
|
||||
membershipRole: 'owner',
|
||||
sieOverlap: false,
|
||||
updates: [],
|
||||
leaseUntil: EPOCH,
|
||||
}
|
||||
mocks.syncAccountTransactions.mockResolvedValue({ imported: 2, duplicates: 5, errors: 0 })
|
||||
mocks.updateBalancesFromSync.mockResolvedValue(undefined)
|
||||
mocks.emit.mockResolvedValue(undefined)
|
||||
})
|
||||
|
||||
it('syncs only the enabled accounts over the gap-aware window and stamps last_synced_at', async () => {
|
||||
const result = await run()
|
||||
expect(result.ok).toBe(true)
|
||||
if (!result.ok) return
|
||||
expect(result).toMatchObject({ connection_id: CONNECTION_ID, bank: 'Swedbank', imported: 2, duplicates: 5 })
|
||||
// Synced 2 days ago: the 7-day floor applies.
|
||||
expect(result.from_date).toBe(new Date(NOW - 7 * DAY_MS).toISOString().split('T')[0])
|
||||
expect(result.to_date).toBe('2026-09-02')
|
||||
expect(mocks.syncAccountTransactions).toHaveBeenCalledTimes(1)
|
||||
expect(mocks.syncAccountTransactions.mock.calls[0][4]).toMatchObject({ uid: 'acc-1' })
|
||||
expect(state.updates.at(-1)).toMatchObject({ last_synced_at: result.last_synced_at })
|
||||
// Write-back keeps the disabled account so the user's selection survives.
|
||||
expect((state.updates.at(-1)!.accounts_data as unknown[]).length).toBe(2)
|
||||
expect(mocks.updateBalancesFromSync).toHaveBeenCalledTimes(1)
|
||||
expect(mocks.emit).toHaveBeenCalledWith(expect.objectContaining({ type: 'transaction.synced' }))
|
||||
})
|
||||
|
||||
it('widens the window to cover a longer gap and asks for the deepest history past a month', async () => {
|
||||
state.connection = connection({ last_synced_at: new Date(NOW - 40 * DAY_MS).toISOString() })
|
||||
const result = await run()
|
||||
expect(result.ok).toBe(true)
|
||||
if (!result.ok) return
|
||||
expect(result.from_date).toBe(new Date(NOW - 41 * DAY_MS).toISOString().split('T')[0])
|
||||
expect(mocks.syncAccountTransactions.mock.calls[0][8]).toMatchObject({ strategy: 'longest' })
|
||||
})
|
||||
|
||||
it('refuses with a cooldown when the connection synced within 15 minutes', async () => {
|
||||
const syncedAt = NOW - 5 * 60 * 1000
|
||||
state.connection = connection({ last_synced_at: new Date(syncedAt).toISOString() })
|
||||
const result = await run()
|
||||
expect(result).toMatchObject({
|
||||
ok: false,
|
||||
code: 'BANK_SYNC_COOLDOWN',
|
||||
next_allowed_at: new Date(syncedAt + SYNC_COOLDOWN_MS).toISOString(),
|
||||
retry_after_seconds: 600,
|
||||
})
|
||||
expect(mocks.syncAccountTransactions).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('claims the durable lease before calling the bank', async () => {
|
||||
await run()
|
||||
expect(state.leaseUntil).toBe(new Date(NOW + SYNC_COOLDOWN_MS).toISOString())
|
||||
// The claim is issued before syncAccountTransactions: the lease row
|
||||
// update is the first write recorded.
|
||||
expect(state.updates[0]).toEqual({ sync_lease_until: state.leaseUntil })
|
||||
})
|
||||
|
||||
it('throttles a failing connection by the lease, not only by last_synced_at', async () => {
|
||||
mocks.syncAccountTransactions.mockRejectedValue(new Error('ASPSP 500'))
|
||||
const first = await run()
|
||||
expect(first).toMatchObject({ ok: false, code: 'BANK_SYNC_FAILED' })
|
||||
// A second instance re-reads the row: the lease is now held.
|
||||
state.connection = connection({ sync_lease_until: state.leaseUntil })
|
||||
const second = await run(NOW + 60 * 1000)
|
||||
expect(second).toMatchObject({
|
||||
ok: false,
|
||||
code: 'BANK_SYNC_COOLDOWN',
|
||||
next_allowed_at: state.leaseUntil,
|
||||
retry_after_seconds: 14 * 60,
|
||||
})
|
||||
expect(mocks.syncAccountTransactions).toHaveBeenCalledTimes(1)
|
||||
})
|
||||
|
||||
it('loses the race to a concurrent claimer and never calls the bank', async () => {
|
||||
// Our read saw no lease; between the read and the claim another
|
||||
// serverless instance took it. The conditional UPDATE returns no row.
|
||||
state.leaseUntil = new Date(NOW + SYNC_COOLDOWN_MS - 1000).toISOString()
|
||||
const result = await run()
|
||||
expect(result).toMatchObject({ ok: false, code: 'BANK_SYNC_COOLDOWN' })
|
||||
expect(mocks.syncAccountTransactions).not.toHaveBeenCalled()
|
||||
expect(mocks.updateBalancesFromSync).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('accepts a sync once a previous lease has expired', async () => {
|
||||
state.leaseUntil = new Date(NOW - 1000).toISOString()
|
||||
state.connection = connection({ sync_lease_until: state.leaseUntil })
|
||||
const result = await run()
|
||||
expect(result.ok).toBe(true)
|
||||
expect(state.leaseUntil).toBe(new Date(NOW + SYNC_COOLDOWN_MS).toISOString())
|
||||
})
|
||||
|
||||
it('answers NOT_FOUND for a connection outside the company or a non-uuid id', async () => {
|
||||
state.connection = null
|
||||
expect(await run()).toMatchObject({ ok: false, code: 'NOT_FOUND' })
|
||||
const bogus = await triggerConnectionSync(makeClient(state) as never, {
|
||||
companyId: COMPANY_ID,
|
||||
userId: 'user-1',
|
||||
connectionId: 'not-a-uuid',
|
||||
log,
|
||||
now: NOW,
|
||||
})
|
||||
expect(bogus).toMatchObject({ ok: false, code: 'NOT_FOUND' })
|
||||
})
|
||||
|
||||
it('answers NOT_FOUND when the caller is not a member of the company, before any lease or bank call', async () => {
|
||||
state.membershipRole = null
|
||||
expect(await run()).toMatchObject({ ok: false, code: 'NOT_FOUND' })
|
||||
expect(state.leaseUntil).toBe(EPOCH)
|
||||
expect(mocks.syncAccountTransactions).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('refuses an expired or pending connection: only BankID can fix those', async () => {
|
||||
state.connection = connection({ status: 'expired' })
|
||||
expect(await run()).toMatchObject({ ok: false, code: 'BANK_SYNC_NOT_ACTIVE', status: 'expired' })
|
||||
state.connection = connection({ status: 'pending_selection' })
|
||||
expect(await run()).toMatchObject({ ok: false, code: 'BANK_SYNC_NOT_ACTIVE' })
|
||||
expect(mocks.syncAccountTransactions).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('retries an errored connection and recovers it to active on success', async () => {
|
||||
state.connection = connection({ status: 'error', error_message: 'Banksynkningen misslyckades.' })
|
||||
const result = await run()
|
||||
expect(result.ok).toBe(true)
|
||||
expect(state.updates.at(-1)).toMatchObject({ status: 'active', error_message: null })
|
||||
})
|
||||
|
||||
it('refuses when every account is deselected', async () => {
|
||||
state.connection = connection({ accounts_data: [{ uid: 'acc-1', enabled: false }] })
|
||||
expect(await run()).toMatchObject({ ok: false, code: 'BANK_SYNC_NO_ACCOUNTS' })
|
||||
})
|
||||
|
||||
it('flips the connection to expired when the bank reports the session dead', async () => {
|
||||
mocks.syncAccountTransactions.mockRejectedValue(new SessionExpiredError(401, 'consent closed'))
|
||||
const result = await run()
|
||||
expect(result).toMatchObject({ ok: false, code: 'BANK_SESSION_EXPIRED', status: 'expired' })
|
||||
expect(state.updates.at(-1)).toMatchObject({ status: 'expired', error_message: REAUTH_REQUIRED_MESSAGE })
|
||||
})
|
||||
|
||||
it('suppresses auto-categorisation over a completed SIE import and for viewers', async () => {
|
||||
state.sieOverlap = true
|
||||
state.membershipRole = 'viewer'
|
||||
await run()
|
||||
expect(mocks.syncAccountTransactions.mock.calls[0][8]).toMatchObject({
|
||||
skipAutoCategorization: true,
|
||||
rawInsertOnly: true,
|
||||
})
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,30 @@
|
||||
/**
|
||||
* How far back the daily cron asks the bank for transactions on an
|
||||
* incremental (non-first) sync.
|
||||
*
|
||||
* A fixed 7-day window silently loses data whenever a connection pauses for
|
||||
* longer than a week: a lapsed subscription that is paid again, a consent
|
||||
* renewed after it expired, an outage. The row still carries the last
|
||||
* successful sync, so the window is widened to cover the gap, with one day
|
||||
* of overlap for late-booked transactions (dedup via external_id makes the
|
||||
* overlap harmless). Capped at the PSD2 90-day limit a bank will serve
|
||||
* without fresh SCA.
|
||||
*
|
||||
* Pure module so the arithmetic is unit-testable.
|
||||
*/
|
||||
|
||||
export const INCREMENTAL_LOOKBACK_DAYS = 7
|
||||
export const MAX_LOOKBACK_DAYS = 90
|
||||
|
||||
const DAY_MS = 24 * 60 * 60 * 1000
|
||||
|
||||
export function incrementalLookbackDays(
|
||||
lastSyncedAt: string | null | undefined,
|
||||
now: number = Date.now(),
|
||||
): number {
|
||||
if (!lastSyncedAt) return INCREMENTAL_LOOKBACK_DAYS
|
||||
const syncedAt = new Date(lastSyncedAt).getTime()
|
||||
if (!Number.isFinite(syncedAt)) return INCREMENTAL_LOOKBACK_DAYS
|
||||
const daysSince = Math.ceil(Math.max(0, now - syncedAt) / DAY_MS)
|
||||
return Math.min(MAX_LOOKBACK_DAYS, Math.max(INCREMENTAL_LOOKBACK_DAYS, daysSince + 1))
|
||||
}
|
||||
@@ -0,0 +1,297 @@
|
||||
/**
|
||||
* Agent-triggered bank sync: the shared runner behind the v1 REST endpoint
|
||||
* POST /companies/{id}/bank-connections/{connectionId}/sync and the MCP tool
|
||||
* gnubok_sync_bank.
|
||||
*
|
||||
* Deliberately narrower than the cookie-session "Synka nu" route in
|
||||
* index.ts: the window is never caller-controlled (the gap-aware incremental
|
||||
* lookback from cron-lookback.ts, 7 to 90 days), and a connection that
|
||||
* synced OR was attempted within SYNC_COOLDOWN_MS answers with a cooldown
|
||||
* instead of another paid Enable Banking round-trip. The attempt guard is a
|
||||
* durable lease on bank_connections.sync_lease_until, claimed with one
|
||||
* conditional UPDATE, so it holds across serverless instances and cold
|
||||
* starts. An unattended agent loop therefore costs at most one sync per
|
||||
* connection per cooldown window, regardless of how often it asks.
|
||||
*
|
||||
* Failures are reported as codes, never thrown, so each surface maps them
|
||||
* to its own envelope (structured-errors.ts BANK_SYNC_*). A dead PSD2
|
||||
* session is flipped to 'expired' here exactly like the web route does:
|
||||
* nothing an API call can do revives it, only BankID in a browser.
|
||||
*
|
||||
* Core cannot import this module (CI guard): the v1 route reaches it via
|
||||
* the extension's registered `services`, against the contract in
|
||||
* lib/bank-sync/trigger-sync-contract.ts.
|
||||
*/
|
||||
import type { SupabaseClient } from '@supabase/supabase-js'
|
||||
import { syncAccountTransactions, type SyncOptions } from './sync'
|
||||
import {
|
||||
SessionExpiredError,
|
||||
REAUTH_REQUIRED_MESSAGE,
|
||||
SYNC_FAILED_MESSAGE,
|
||||
} from './api-client'
|
||||
import { incrementalLookbackDays } from './cron-lookback'
|
||||
import { updateBalancesFromSync } from '@/lib/cash-accounts/service'
|
||||
import { eventBus } from '@/lib/events/bus'
|
||||
import {
|
||||
SYNC_COOLDOWN_MS,
|
||||
type TriggerSyncInput,
|
||||
type TriggerSyncResult,
|
||||
} from '@/lib/bank-sync/trigger-sync-contract'
|
||||
import type { StoredAccount } from '../types'
|
||||
import type { Transaction } from '@/types'
|
||||
|
||||
export { SYNC_COOLDOWN_MS }
|
||||
export type { TriggerSyncInput, TriggerSyncResult }
|
||||
|
||||
function isUuid(value: string): boolean {
|
||||
return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)
|
||||
}
|
||||
|
||||
function cooldownResult(connectionId: string, nextAllowed: number, now: number): TriggerSyncResult {
|
||||
return {
|
||||
ok: false,
|
||||
code: 'BANK_SYNC_COOLDOWN',
|
||||
connection_id: connectionId,
|
||||
next_allowed_at: new Date(nextAllowed).toISOString(),
|
||||
retry_after_seconds: Math.max(1, Math.ceil((nextAllowed - now) / 1000)),
|
||||
}
|
||||
}
|
||||
|
||||
export async function triggerConnectionSync(
|
||||
supabase: SupabaseClient,
|
||||
input: TriggerSyncInput,
|
||||
): Promise<TriggerSyncResult> {
|
||||
const { companyId, userId, connectionId, log } = input
|
||||
const now = input.now ?? Date.now()
|
||||
|
||||
if (!isUuid(connectionId)) {
|
||||
return { ok: false, code: 'NOT_FOUND', connection_id: connectionId }
|
||||
}
|
||||
|
||||
const { data: connection, error: connectionError } = await supabase
|
||||
.from('bank_connections')
|
||||
.select(
|
||||
'id, company_id, bank_name, status, accounts_data, last_synced_at, error_message, sync_lease_until',
|
||||
)
|
||||
.eq('id', connectionId)
|
||||
.eq('company_id', companyId)
|
||||
.maybeSingle()
|
||||
|
||||
if (connectionError) throw connectionError
|
||||
if (!connection) {
|
||||
return { ok: false, code: 'NOT_FOUND', connection_id: connectionId }
|
||||
}
|
||||
|
||||
// 'error' is retryable (a transient upstream failure parks the row there
|
||||
// while the session is alive); 'expired' and the pending states are not:
|
||||
// they need the browser flow.
|
||||
if (connection.status !== 'active' && connection.status !== 'error') {
|
||||
return {
|
||||
ok: false,
|
||||
code: 'BANK_SYNC_NOT_ACTIVE',
|
||||
connection_id: connectionId,
|
||||
status: connection.status,
|
||||
}
|
||||
}
|
||||
|
||||
// Membership is enforced by both callers before we run (withApiV1's
|
||||
// company resolution, the MCP dispatcher's resolveMcpCompanyContext), but
|
||||
// this runner writes transactions and bills a bank call, so it checks the
|
||||
// caller's membership itself as well: a service-role client with the
|
||||
// wrong userId must never get past this point. Viewers get raw inserts
|
||||
// only, exactly like the web route.
|
||||
const { data: membership, error: membershipError } = await supabase
|
||||
.from('company_members')
|
||||
.select('role')
|
||||
.eq('company_id', companyId)
|
||||
.eq('user_id', userId)
|
||||
.maybeSingle()
|
||||
if (membershipError) throw membershipError
|
||||
if (!membership) {
|
||||
return { ok: false, code: 'NOT_FOUND', connection_id: connectionId }
|
||||
}
|
||||
const isViewer = (membership as { role?: string }).role === 'viewer'
|
||||
|
||||
// A successful sync (ours, the web button's or the cron's) within the
|
||||
// window: the data is fresh, say so without touching the bank.
|
||||
const lastSynced = connection.last_synced_at
|
||||
? new Date(connection.last_synced_at as string).getTime()
|
||||
: null
|
||||
if (lastSynced !== null && now - lastSynced < SYNC_COOLDOWN_MS) {
|
||||
return cooldownResult(connectionId, lastSynced + SYNC_COOLDOWN_MS, now)
|
||||
}
|
||||
// A lease still held from a recent ATTEMPT (success or failure): cheap
|
||||
// read-side answer before the write below.
|
||||
const heldLease = connection.sync_lease_until
|
||||
? new Date(connection.sync_lease_until as string).getTime()
|
||||
: null
|
||||
if (heldLease !== null && heldLease > now) {
|
||||
return cooldownResult(connectionId, heldLease, now)
|
||||
}
|
||||
|
||||
const allAccounts = ((connection.accounts_data as StoredAccount[] | null) ?? []).map((a) => ({
|
||||
...a,
|
||||
}))
|
||||
const accounts = allAccounts.filter((a) => a.enabled !== false)
|
||||
if (accounts.length === 0) {
|
||||
return { ok: false, code: 'BANK_SYNC_NO_ACCOUNTS', connection_id: connectionId }
|
||||
}
|
||||
|
||||
// Durable, atomic cooldown claim. One conditional UPDATE: the lease is
|
||||
// taken only if the current one has expired (the column defaults to epoch,
|
||||
// so "never claimed" needs no NULL branch), and Postgres row locking
|
||||
// serialises concurrent claimers, so two agent calls landing on different
|
||||
// serverless instances (or retries of a failing connection after a cold
|
||||
// start) can never both reach the bank. The lease stays for the full
|
||||
// window whether the sync succeeds or fails: that IS the throttle.
|
||||
const nowIso = new Date(now).toISOString()
|
||||
const leaseUntil = now + SYNC_COOLDOWN_MS
|
||||
const { data: claimed, error: claimError } = await supabase
|
||||
.from('bank_connections')
|
||||
.update({ sync_lease_until: new Date(leaseUntil).toISOString() })
|
||||
.eq('id', connectionId)
|
||||
.eq('company_id', companyId)
|
||||
.lte('sync_lease_until', nowIso)
|
||||
.select('id')
|
||||
if (claimError) throw claimError
|
||||
if (!claimed || claimed.length === 0) {
|
||||
// Lost the race: another caller claimed between our read and this write.
|
||||
// Its lease started at most a moment ago, so ours is the honest estimate.
|
||||
log.info('agent-triggered bank sync: lease held by a concurrent caller', { connectionId })
|
||||
return cooldownResult(connectionId, leaseUntil, now)
|
||||
}
|
||||
|
||||
const lookbackDays = incrementalLookbackDays(connection.last_synced_at as string | null, now)
|
||||
const toDate = new Date(now).toISOString().split('T')[0]
|
||||
const fromDate = new Date(now - lookbackDays * 24 * 60 * 60 * 1000).toISOString().split('T')[0]
|
||||
const syncStartedAt = new Date(now).toISOString()
|
||||
|
||||
try {
|
||||
// Same SIE-overlap guard as the web route and the cron: never
|
||||
// auto-categorise into a range a completed SIE import already covers.
|
||||
const { data: sieOverlap } = await supabase
|
||||
.from('sie_imports')
|
||||
.select('id')
|
||||
.eq('company_id', companyId)
|
||||
.eq('status', 'completed')
|
||||
.gte('fiscal_year_end', fromDate)
|
||||
.limit(1)
|
||||
.maybeSingle()
|
||||
|
||||
const syncOptions: SyncOptions = {
|
||||
...(sieOverlap ? { skipAutoCategorization: true } : {}),
|
||||
...(isViewer ? { rawInsertOnly: true } : {}),
|
||||
...(lookbackDays >= 30 ? { strategy: 'longest' as const } : {}),
|
||||
}
|
||||
|
||||
const results = await Promise.all(
|
||||
accounts.map((account) =>
|
||||
syncAccountTransactions(
|
||||
supabase,
|
||||
companyId,
|
||||
userId,
|
||||
connection.id as string,
|
||||
account,
|
||||
fromDate,
|
||||
toDate,
|
||||
undefined,
|
||||
syncOptions,
|
||||
),
|
||||
),
|
||||
)
|
||||
const imported = results.reduce((sum, r) => sum + r.imported, 0)
|
||||
const duplicates = results.reduce((sum, r) => sum + r.duplicates, 0)
|
||||
|
||||
const syncedAt = new Date().toISOString()
|
||||
await updateBalancesFromSync(
|
||||
supabase,
|
||||
companyId,
|
||||
connection.id as string,
|
||||
allAccounts.map((a) => ({
|
||||
external_uid: a.uid,
|
||||
balance: a.balance,
|
||||
available_balance: a.available_balance,
|
||||
balance_updated_at: a.balance_updated_at,
|
||||
})),
|
||||
)
|
||||
await supabase
|
||||
.from('bank_connections')
|
||||
.update({
|
||||
accounts_data: allAccounts,
|
||||
last_synced_at: syncedAt,
|
||||
...(connection.status === 'error' ? { status: 'active' } : {}),
|
||||
...(connection.status === 'error' || connection.error_message ? { error_message: null } : {}),
|
||||
})
|
||||
.eq('id', connection.id)
|
||||
.eq('company_id', companyId)
|
||||
|
||||
if (imported > 0) {
|
||||
const { data: syncedTransactions } = await supabase
|
||||
.from('transactions')
|
||||
.select('*')
|
||||
.eq('company_id', companyId)
|
||||
.eq('bank_connection_id', connection.id)
|
||||
.gte('created_at', syncStartedAt)
|
||||
.order('created_at', { ascending: false })
|
||||
.limit(imported)
|
||||
if (syncedTransactions && syncedTransactions.length > 0) {
|
||||
await eventBus.emit({
|
||||
type: 'transaction.synced',
|
||||
payload: { transactions: syncedTransactions as Transaction[], userId, companyId },
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
log.info('agent-triggered bank sync completed', {
|
||||
connectionId,
|
||||
imported,
|
||||
duplicates,
|
||||
lookbackDays,
|
||||
})
|
||||
|
||||
return {
|
||||
ok: true,
|
||||
connection_id: connection.id as string,
|
||||
bank: (connection.bank_name as string | null) ?? null,
|
||||
imported,
|
||||
duplicates,
|
||||
from_date: fromDate,
|
||||
to_date: toDate,
|
||||
last_synced_at: syncedAt,
|
||||
}
|
||||
} catch (error) {
|
||||
if (error instanceof SessionExpiredError) {
|
||||
log.warn('agent-triggered bank sync: session expired', { connectionId })
|
||||
await supabase
|
||||
.from('bank_connections')
|
||||
.update({ status: 'expired', error_message: REAUTH_REQUIRED_MESSAGE })
|
||||
.eq('id', connection.id)
|
||||
.eq('company_id', companyId)
|
||||
return {
|
||||
ok: false,
|
||||
code: 'BANK_SESSION_EXPIRED',
|
||||
connection_id: connectionId,
|
||||
status: 'expired',
|
||||
}
|
||||
}
|
||||
|
||||
log.error('agent-triggered bank sync failed', {
|
||||
connectionId,
|
||||
message: error instanceof Error ? error.message : String(error),
|
||||
name: error instanceof Error ? error.name : undefined,
|
||||
})
|
||||
if (connection.status === 'error') {
|
||||
await supabase
|
||||
.from('bank_connections')
|
||||
.update({ error_message: SYNC_FAILED_MESSAGE })
|
||||
.eq('id', connection.id)
|
||||
.eq('company_id', companyId)
|
||||
}
|
||||
return {
|
||||
ok: false,
|
||||
code: 'BANK_SYNC_FAILED',
|
||||
connection_id: connectionId,
|
||||
status: connection.status as string,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,153 @@
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
||||
|
||||
// Agent-triggered PSD2 sync: the MCP twin of
|
||||
// POST /api/v1/companies/{id}/bank-connections/{connectionId}/sync.
|
||||
// The runner itself is covered in extensions/general/enable-banking; this
|
||||
// file pins the tool's contract: scope, capability gate, the in-band
|
||||
// cooldown answer, and that real failures flow through the coded envelope.
|
||||
|
||||
const mocks = vi.hoisted(() => ({
|
||||
triggerConnectionSync: vi.fn(),
|
||||
}))
|
||||
|
||||
vi.mock('@/extensions/general/enable-banking/lib/trigger-sync', async () => {
|
||||
const actual = await vi.importActual<
|
||||
typeof import('@/extensions/general/enable-banking/lib/trigger-sync')
|
||||
>('@/extensions/general/enable-banking/lib/trigger-sync')
|
||||
return {
|
||||
...actual,
|
||||
triggerConnectionSync: (...args: unknown[]) => mocks.triggerConnectionSync(...args),
|
||||
}
|
||||
})
|
||||
|
||||
import { TOOL_SCOPE_MAP } from '@/lib/auth/api-keys'
|
||||
import { eventBus } from '@/lib/events/bus'
|
||||
import { MCP_TOOL_CAPABILITY_MAP } from '@/lib/entitlements/keys'
|
||||
import { tools } from '../server'
|
||||
|
||||
const COMPANY_ID = '11111111-1111-4111-8111-111111111111'
|
||||
const CONNECTION_ID = '22222222-2222-4222-8222-222222222222'
|
||||
const tool = tools.find((t) => t.name === 'gnubok_sync_bank')!
|
||||
|
||||
describe('gnubok_sync_bank', () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks()
|
||||
eventBus.clear()
|
||||
})
|
||||
afterEach(() => {
|
||||
vi.unstubAllEnvs()
|
||||
})
|
||||
|
||||
it('is a transactions:write tool gated on bank_sync and flagged open-world', () => {
|
||||
expect(TOOL_SCOPE_MAP.gnubok_sync_bank).toBe('transactions:write')
|
||||
expect(MCP_TOOL_CAPABILITY_MAP.gnubok_sync_bank).toBe('bank_sync')
|
||||
expect(tool.annotations.readOnlyHint).toBe(false)
|
||||
expect(tool.annotations.openWorldHint).toBe(true)
|
||||
expect(tool.inputSchema).toMatchObject({ additionalProperties: false, required: ['connection_id'] })
|
||||
})
|
||||
|
||||
it('runs the shared sync runner for the company and reports the outcome', async () => {
|
||||
mocks.triggerConnectionSync.mockResolvedValue({
|
||||
ok: true,
|
||||
connection_id: CONNECTION_ID,
|
||||
bank: 'Swedbank',
|
||||
imported: 3,
|
||||
duplicates: 12,
|
||||
from_date: '2026-08-26',
|
||||
to_date: '2026-09-02',
|
||||
last_synced_at: '2026-09-02T09:14:03.000Z',
|
||||
})
|
||||
const supabase = {} as never
|
||||
const result = (await tool.execute(
|
||||
{ connection_id: CONNECTION_ID },
|
||||
COMPANY_ID,
|
||||
'user-1',
|
||||
supabase,
|
||||
)) as Record<string, unknown>
|
||||
|
||||
expect(mocks.triggerConnectionSync).toHaveBeenCalledWith(
|
||||
supabase,
|
||||
expect.objectContaining({ companyId: COMPANY_ID, userId: 'user-1', connectionId: CONNECTION_ID }),
|
||||
)
|
||||
expect(result).toMatchObject({
|
||||
synced: true,
|
||||
connection_id: CONNECTION_ID,
|
||||
bank: 'Swedbank',
|
||||
imported: 3,
|
||||
duplicates: 12,
|
||||
last_synced_at: '2026-09-02T09:14:03.000Z',
|
||||
next_allowed_at: null,
|
||||
})
|
||||
expect(result.instructions).toContain('3 new transaction')
|
||||
})
|
||||
|
||||
it('tells the agent nothing was missing when the bank had no news', async () => {
|
||||
mocks.triggerConnectionSync.mockResolvedValue({
|
||||
ok: true,
|
||||
connection_id: CONNECTION_ID,
|
||||
bank: 'SEB',
|
||||
imported: 0,
|
||||
duplicates: 4,
|
||||
from_date: '2026-08-26',
|
||||
to_date: '2026-09-02',
|
||||
last_synced_at: '2026-09-02T09:14:03.000Z',
|
||||
})
|
||||
const result = (await tool.execute(
|
||||
{ connection_id: CONNECTION_ID },
|
||||
COMPANY_ID,
|
||||
'user-1',
|
||||
{} as never,
|
||||
)) as Record<string, unknown>
|
||||
expect(result.synced).toBe(true)
|
||||
expect(result.instructions).toContain('nothing new')
|
||||
})
|
||||
|
||||
it('answers a cooldown in-band with next_allowed_at instead of throwing', async () => {
|
||||
mocks.triggerConnectionSync.mockResolvedValue({
|
||||
ok: false,
|
||||
code: 'BANK_SYNC_COOLDOWN',
|
||||
connection_id: CONNECTION_ID,
|
||||
next_allowed_at: '2026-09-02T09:29:03.000Z',
|
||||
retry_after_seconds: 600,
|
||||
})
|
||||
const result = (await tool.execute(
|
||||
{ connection_id: CONNECTION_ID },
|
||||
COMPANY_ID,
|
||||
'user-1',
|
||||
{} as never,
|
||||
)) as Record<string, unknown>
|
||||
expect(result).toMatchObject({
|
||||
synced: false,
|
||||
connection_id: CONNECTION_ID,
|
||||
next_allowed_at: '2026-09-02T09:29:03.000Z',
|
||||
})
|
||||
expect(result.instructions).toContain('next_allowed_at')
|
||||
// A cooldown can follow a FAILED attempt too (durable lease): the agent
|
||||
// must be told to check freshness rather than assume it.
|
||||
expect(result.instructions).toContain('last_synced_at')
|
||||
})
|
||||
|
||||
it.each([
|
||||
'NOT_FOUND',
|
||||
'BANK_SYNC_NOT_ACTIVE',
|
||||
'BANK_SYNC_NO_ACCOUNTS',
|
||||
'BANK_SESSION_EXPIRED',
|
||||
'BANK_SYNC_FAILED',
|
||||
] as const)('throws a coded error for %s so the dispatch envelope carries the remediation', async (code) => {
|
||||
mocks.triggerConnectionSync.mockResolvedValue({ ok: false, code, connection_id: CONNECTION_ID })
|
||||
await expect(
|
||||
tool.execute({ connection_id: CONNECTION_ID }, COMPANY_ID, 'user-1', {} as never),
|
||||
).rejects.toMatchObject({ code })
|
||||
})
|
||||
|
||||
it('passes a blank connection_id through as an empty string (runner answers NOT_FOUND)', async () => {
|
||||
mocks.triggerConnectionSync.mockResolvedValue({ ok: false, code: 'NOT_FOUND', connection_id: '' })
|
||||
await expect(tool.execute({}, COMPANY_ID, 'user-1', {} as never)).rejects.toMatchObject({
|
||||
code: 'NOT_FOUND',
|
||||
})
|
||||
expect(mocks.triggerConnectionSync).toHaveBeenCalledWith(
|
||||
expect.anything(),
|
||||
expect.objectContaining({ connectionId: '' }),
|
||||
)
|
||||
})
|
||||
})
|
||||
@@ -251,6 +251,7 @@ import { findDuplicatePaymentCandidatesForInvoice } from '@/lib/invoices/duplica
|
||||
import { getEmailService } from '@/lib/email/service'
|
||||
import { hasCapability, capabilityBlockedError } from '@/lib/entitlements/has-capability'
|
||||
import { MCP_TOOL_CAPABILITY_MAP } from '@/lib/entitlements/keys'
|
||||
import { triggerConnectionSync } from '@/extensions/general/enable-banking/lib/trigger-sync'
|
||||
import {
|
||||
completePendingDocumentUpload,
|
||||
createPendingDocumentUpload,
|
||||
@@ -3759,6 +3760,85 @@ export const tools: McpTool[] = [
|
||||
},
|
||||
},
|
||||
|
||||
{
|
||||
name: 'gnubok_sync_bank',
|
||||
keywords: ['synka bank', 'banksynk', 'hämta banktransaktioner', 'uppdatera bank', 'synka nu'],
|
||||
title: 'Sync Bank Now',
|
||||
description:
|
||||
'Sync one PSD2 bank connection now instead of waiting for the nightly run. Use when gnubok_connect_bank shows a stale last_synced_at on an active connection. Server picks the window; synced=false with next_allowed_at means a sync ran or was attempted within 15 min.',
|
||||
inputSchema: {
|
||||
type: 'object',
|
||||
additionalProperties: false,
|
||||
required: ['connection_id'],
|
||||
properties: {
|
||||
connection_id: {
|
||||
type: 'string',
|
||||
description: 'connection_id from gnubok_connect_bank.',
|
||||
},
|
||||
},
|
||||
},
|
||||
outputSchema: {
|
||||
type: 'object',
|
||||
properties: {
|
||||
synced: { type: 'boolean' },
|
||||
connection_id: { type: 'string' },
|
||||
bank: { type: ['string', 'null'] },
|
||||
imported: { type: 'integer' },
|
||||
duplicates: { type: 'integer' },
|
||||
last_synced_at: { type: ['string', 'null'] },
|
||||
next_allowed_at: { type: ['string', 'null'] },
|
||||
instructions: { type: 'string' },
|
||||
},
|
||||
required: ['synced', 'connection_id', 'instructions'],
|
||||
},
|
||||
annotations: ANNOTATIONS_WRITE_OPEN_WORLD,
|
||||
async execute(args, companyId, userId, supabase) {
|
||||
const connectionId = typeof args.connection_id === 'string' ? args.connection_id.trim() : ''
|
||||
const result = await triggerConnectionSync(supabase, {
|
||||
companyId,
|
||||
userId,
|
||||
connectionId,
|
||||
log,
|
||||
})
|
||||
|
||||
if (!result.ok) {
|
||||
// Cooldown is not a failure: the data is fresh. Say so in-band so the
|
||||
// agent reads on instead of retrying; everything else is a real
|
||||
// error and flows through the structured envelope (BANK_SYNC_* codes
|
||||
// carry the remediation, incl. "hand the user the connect link").
|
||||
if (result.code === 'BANK_SYNC_COOLDOWN') {
|
||||
return {
|
||||
synced: false,
|
||||
connection_id: result.connection_id,
|
||||
bank: null,
|
||||
last_synced_at: null,
|
||||
next_allowed_at: result.next_allowed_at ?? null,
|
||||
instructions:
|
||||
'A sync ran or was attempted on this connection within the last 15 minutes. Check last_synced_at via gnubok_connect_bank: if it is fresh, transactions and balances are already current, continue with gnubok_list_uncategorized_transactions. If it is still stale, the previous attempt failed; retry once after next_allowed_at, never before.',
|
||||
}
|
||||
}
|
||||
throw Object.assign(
|
||||
new Error(`Bank sync refused for connection ${result.connection_id}: ${result.code}`),
|
||||
{ code: result.code },
|
||||
)
|
||||
}
|
||||
|
||||
return {
|
||||
synced: true,
|
||||
connection_id: result.connection_id,
|
||||
bank: result.bank,
|
||||
imported: result.imported,
|
||||
duplicates: result.duplicates,
|
||||
last_synced_at: result.last_synced_at,
|
||||
next_allowed_at: null,
|
||||
instructions:
|
||||
result.imported > 0
|
||||
? `${result.imported} new transaction(s) fetched from the bank (${result.from_date} to ${result.to_date}). Continue with gnubok_list_uncategorized_transactions.`
|
||||
: `The bank had nothing new for ${result.from_date} to ${result.to_date}: the data was already complete. Banks report with up to 48 hours of delay, so today's transactions often arrive tomorrow; do not call again for that.`,
|
||||
}
|
||||
},
|
||||
},
|
||||
|
||||
{
|
||||
name: 'gnubok_connect_skatteverket',
|
||||
keywords: ['skatteverket', 'koppla skatteverket', 'deklarationsombud'],
|
||||
|
||||
Reference in New Issue
Block a user