Jakob Wennberg
dc07ca8872
Decision (option a): a private marking stays a real booking (eget uttag/insattning), so it remains blocked in a locked or closed period; the legal escape for rows that are not affarshandelser is ignore. Private + locked now returns TX_CATEGORIZE_PRIVATE_PERIOD_LOCKED with remediation naming the ignore paths instead of a bare PERIOD_LOCKED, on all four categorize surfaces and the bulk driver. New v1 POST/DELETE /transactions/{id}/ignore (isTransactionBooked-based 409, idempotent) and a staged MCP gnubok_ignore_transaction (+ accounted_ alias, search visibility to respect the tools/list payload ceiling) with operation_type ignore_transaction; the CHECK pair 20260831070000/070001 rebuilds the constraint from main's newest list plus the new value. Dashboard toast gains an Ignorera i stallet action. Closes #1661
433 lines
26 KiB
TypeScript
433 lines
26 KiB
TypeScript
/**
|
|
* API-key scope catalogue: scope ids, labels, groups and the MCP tool map.
|
|
*
|
|
* Pure data with no server imports, so client components (the settings
|
|
* panel) can bundle it without dragging in crypto or the service-role
|
|
* Supabase client that lib/auth/api-keys.ts needs. api-keys.ts re-exports
|
|
* everything here; server code keeps importing from there.
|
|
*/
|
|
|
|
// ── API Key Scopes ──────────────────────────────────────────
|
|
|
|
export const API_KEY_SCOPES = {
|
|
'transactions:read': { label: 'Transaktioner: läs', description: 'Lista transaktioner, mallförslag, kategoriförslag' },
|
|
'transactions:write': { label: 'Transaktioner: skriv', description: 'Kategorisera, av-kategorisera, ignorera, kvittomatchning, koppling mot faktura' },
|
|
'customers:read': { label: 'Kunder: läs', description: 'Lista kunder' },
|
|
'customers:write': { label: 'Kunder: skriv', description: 'Skapa och uppdatera kunder' },
|
|
'articles:read': { label: 'Artiklar: läs', description: 'Lista artiklar i artikelregistret' },
|
|
'articles:write': { label: 'Artiklar: skriv', description: 'Skapa och uppdatera artiklar' },
|
|
'invoices:read': { label: 'Fakturor: läs', description: 'Lista fakturor' },
|
|
'invoices:write': { label: 'Fakturor: skriv', description: 'Skapa, skicka, markera betald/skickad' },
|
|
'suppliers:read': { label: 'Leverantörer: läs', description: 'Lista leverantörer och leverantörsfakturor, hitta verifikat-kandidater' },
|
|
'suppliers:write': { label: 'Leverantörer: skriv', description: 'Skapa leverantörer; godkänn, kreditera, betal-länka och hantera leverantörsfakturor' },
|
|
'reports:read': { label: 'Rapporter: läs', description: 'Kontoplan, huvudbok, balansräkning, resultaträkning, moms, KPI, reskontra, perioder, bankavstämning, SIE-export' },
|
|
'bookkeeping:write': { label: 'Bokföring: skriv', description: 'Stänga/låsa perioder, ingående balans, bokslut, SIE-import, voucher-gap-förklaringar, kontoplan (skapa/ändra konton), verifikat-anteckningar' },
|
|
'payroll:read': { label: 'Löner: läs', description: 'Lista anställda, lönekörningar, lönejournal, körjournal' },
|
|
'payroll:write': { label: 'Löner: skriv', description: 'Skapa lönekörning, beräkna, generera AGI, logga körjournalresor' },
|
|
// v1 REST API: added Phase 1
|
|
'companies:read': { label: 'Företag: läs', description: 'Lista och visa företagsprofiler som API-nyckeln har tillgång till' },
|
|
'companies:write': { label: 'Företag: skriv', description: 'Skapa nya företag och uppdatera företagsinställningar (gnubok_create_company, stagade verktyg, REST POST /api/v1/companies och PATCH /api/v1/companies/{companyId}/settings)' },
|
|
'events:read': { label: 'Händelser: läs', description: 'Polla händelseloggen (event_log) som webhook-fallback' },
|
|
'webhooks:manage': { label: 'Webhooks: hantera', description: 'Skapa, lista, uppdatera och radera webhook-prenumerationer' },
|
|
'operations:read': { label: 'Operationer: läs', description: 'Hämta status för långkörande operationer (importer, bokslut, omvärdering)' },
|
|
'documents:read': { label: 'Dokument: läs', description: 'Lista och hämta dokumentbilagor' },
|
|
'documents:write': { label: 'Dokument: skriv', description: 'Ladda upp och koppla dokument till verifikationer' },
|
|
'compliance:read': { label: 'Compliance: läs', description: 'Pre-flight-kontroller: momsstängning, bokslutsberedskap, voucher-gap, IB/UB-kontinuitet; Skatteverket-status (moms + AGI)' },
|
|
'skatteverket:write': { label: 'Skatteverket: skriv', description: 'Lämna momsdeklaration och arbetsgivardeklaration (AGI) till Skatteverket (stagas; signeras med BankID)' },
|
|
'agent:read': { label: 'Agent: läs', description: 'Specialiserad bokföringsassistent: profil, laddade specialister/atomer, minnen (briefing + skill-katalog)' },
|
|
'agent:write': { label: 'Agent: skriv', description: 'Spara och ta bort agentens minnen om företaget (remember_fact, forget_fact)' },
|
|
'pending_operations:read': { label: 'Stagade operationer: läs', description: 'Lista pending_operations (staged writes awaiting approval)' },
|
|
'pending_operations:approve': { label: 'Stagade operationer: godkänn', description: 'Godkänn eller avvisa stagade operationer via API/MCP: agenten ersätter web-UI:s granskning' },
|
|
// Reconciliation (account-keyed: bank accounts + skattekonto). Reads cover
|
|
// the account list, the bridge and the item buckets; writes cover links
|
|
// (match/unmatch) and ignore flags. Links never touch the ledger.
|
|
'reconciliation:read': { label: 'Avstämning: läs', description: 'Konton att stämma av, bryggan per konto och raderna bakom den (bank + skattekonto)' },
|
|
'reconciliation:write': { label: 'Avstämning: skriv', description: 'Koppla och koppla bort händelser mot verifikat, ignorera rader (MCP stagar; REST skriver direkt)' },
|
|
'reconciliation:signoff': { label: 'Avstämning: signera', description: 'Markera ett konto som avstämt t.o.m. ett datum och öppna en signering igen (MCP stagar; REST skriver direkt)' },
|
|
} as const
|
|
|
|
export type ApiKeyScope = keyof typeof API_KEY_SCOPES
|
|
|
|
export const ALL_SCOPES: ApiKeyScope[] = Object.keys(API_KEY_SCOPES) as ApiKeyScope[]
|
|
|
|
/** The read-only scopes assigned to keys with no explicit scopes (legacy/null). */
|
|
export const DEFAULT_SCOPES: ApiKeyScope[] = [
|
|
'transactions:read',
|
|
'customers:read',
|
|
'articles:read',
|
|
'invoices:read',
|
|
'suppliers:read',
|
|
'reports:read',
|
|
]
|
|
|
|
/**
|
|
* Default scope grant for OAuth-issued keys when the client did not pass an
|
|
* explicit `scope` parameter at /authorize. Read-only by design: every
|
|
* write or approval scope must be requested explicitly by the client AND
|
|
* affirmatively ticked by the user on the consent screen.
|
|
*
|
|
* Rationale (do not weaken without a documented security decision):
|
|
* - GDPR Art. 25(2) data-protection-by-default: the minimum-necessary
|
|
* access set must be the silent baseline.
|
|
* - ISO 27001:2022 A.5.18 / A.8.2 / SOC 2 CC6.3: privileged capabilities
|
|
* (write, approve) must not be bundled into a default grant.
|
|
* - Segregation of Duties (findStageApproveConflict below): granting any
|
|
* STAGING_SCOPES member together with `pending_operations:approve` on a
|
|
* single key lets an automated agent both stage AND commit financial
|
|
* postings without a human-in-the-loop review. Keeping the default
|
|
* read-only prevents this combination from being silently issued.
|
|
* - BFL 5 kap 5§ / BFNAR 2013:2 behandlingshistorik: write paths that
|
|
* create or modify verifikationer must be opt-in at the authorization
|
|
* layer; conversational acknowledgement at the agent layer is not an
|
|
* auditable substitute.
|
|
*/
|
|
export const DEFAULT_OAUTH_SCOPES: ApiKeyScope[] = [
|
|
'transactions:read',
|
|
'customers:read',
|
|
'articles:read',
|
|
'invoices:read',
|
|
'suppliers:read',
|
|
'reports:read',
|
|
'companies:read',
|
|
'events:read',
|
|
'operations:read',
|
|
'documents:read',
|
|
'compliance:read',
|
|
'payroll:read',
|
|
'pending_operations:read',
|
|
]
|
|
|
|
/**
|
|
* Scopes advertised in the RFC 8414 authorization-server metadata document
|
|
* (/.well-known/oauth-authorization-server). Restricted to the same set that
|
|
* /authorize will grant by default: destructive scopes still work when
|
|
* requested explicitly, they just aren't enumerated for unauthenticated
|
|
* callers (defense-in-depth against scope-escalation reconnaissance).
|
|
*/
|
|
export const PUBLIC_OAUTH_METADATA_SCOPES: ApiKeyScope[] = [...DEFAULT_OAUTH_SCOPES]
|
|
|
|
/**
|
|
* Scopes that allow staging a pending_operation. Used to detect a
|
|
* segregation-of-duties conflict when paired with `pending_operations:approve`
|
|
* on the same API key (ISO 27001:2022 A.5.3, SOC 2 CC6.1).
|
|
*
|
|
* Documented system control (BFNAR 2013:2 systemdokumentation): `agent:write`
|
|
* is deliberately NOT a staging scope. The memory tools it gates
|
|
* (gnubok_remember_fact/forget_fact) write advisory agent context: they
|
|
* cannot create, mutate, or stage räkenskapsinformation, so memory-write +
|
|
* approve on one key does not let an agent both stage and commit bookkeeping.
|
|
* If a future memory surface ever feeds DIRECTLY into voucher generation
|
|
* (rather than via a separately staged-and-approved operation), revisit this
|
|
* classification.
|
|
*/
|
|
export const STAGING_SCOPES: ApiKeyScope[] = [
|
|
'transactions:write',
|
|
'customers:write',
|
|
'articles:write',
|
|
'invoices:write',
|
|
'suppliers:write',
|
|
'bookkeeping:write',
|
|
'payroll:write',
|
|
'documents:write',
|
|
'companies:write',
|
|
// Skatteverket submit tools stage submit_vat_declaration / submit_agi, so a
|
|
// key holding both this and pending_operations:approve is a SoD conflict:
|
|
// findStageApproveConflict picks it up automatically from this list.
|
|
'skatteverket:write',
|
|
// gnubok_reconcile_match / gnubok_reconcile_unmatch stage reconciliation_*
|
|
// operations; same SoD reasoning.
|
|
'reconciliation:write',
|
|
// gnubok_reconcile_signoff stages reconciliation_signoff.
|
|
'reconciliation:signoff',
|
|
]
|
|
|
|
/**
|
|
* Detect a segregation-of-duties conflict between staging and approval scopes
|
|
* on the same key. Returns the offending staging scope, or null when the
|
|
* combination is clean. Callers may choose to block, warn, or record an
|
|
* acknowledged risk acceptance.
|
|
*
|
|
* Granting both stage+approve to the same actor lets an automated agent both
|
|
* stage AND commit financial postings without a human-in-the-loop review,
|
|
* which is the explicit control surface for BFNAR 2013:2 (behandlingshistorik)
|
|
* and BFL 5 kap 5§ traceability requirements.
|
|
*/
|
|
export function findStageApproveConflict(scopes: ApiKeyScope[]): ApiKeyScope | null {
|
|
if (!scopes.includes('pending_operations:approve')) return null
|
|
return scopes.find((s) => STAGING_SCOPES.includes(s)) ?? null
|
|
}
|
|
|
|
/**
|
|
* One entry per scope group, shared by every surface that lets a human pick
|
|
* scopes (settings panel, OAuth consent page). Every scope in API_KEY_SCOPES
|
|
* belongs to exactly one group: lib/auth/__tests__/scope-catalog.test.ts
|
|
* enforces it, so a scope added to the catalogue without a group fails CI
|
|
* instead of silently vanishing from the pickers.
|
|
*/
|
|
export type ScopeGroup = {
|
|
/** Stable id: React key and i18n suffix (`group_<domain>`) in the panel. */
|
|
domain: string
|
|
/** Swedish label for surfaces without next-intl (the OAuth consent page). */
|
|
label: string
|
|
/** Display order: the `:read` scope first, then the elevated ones. */
|
|
scopes: readonly ApiKeyScope[]
|
|
}
|
|
|
|
export const SCOPE_GROUPS: readonly ScopeGroup[] = [
|
|
{ domain: 'companies', label: 'Företag', scopes: ['companies:read', 'companies:write'] },
|
|
{ domain: 'transactions', label: 'Transaktioner', scopes: ['transactions:read', 'transactions:write'] },
|
|
{ domain: 'reconciliation', label: 'Avstämning', scopes: ['reconciliation:read', 'reconciliation:write', 'reconciliation:signoff'] },
|
|
{ domain: 'customers', label: 'Kunder', scopes: ['customers:read', 'customers:write'] },
|
|
{ domain: 'articles', label: 'Artiklar', scopes: ['articles:read', 'articles:write'] },
|
|
{ domain: 'invoices', label: 'Fakturor', scopes: ['invoices:read', 'invoices:write'] },
|
|
{ domain: 'suppliers', label: 'Leverantörer', scopes: ['suppliers:read', 'suppliers:write'] },
|
|
{ domain: 'reports', label: 'Rapporter', scopes: ['reports:read'] },
|
|
{ domain: 'bookkeeping', label: 'Bokföring', scopes: ['bookkeeping:write'] },
|
|
{ domain: 'payroll', label: 'Löner', scopes: ['payroll:read', 'payroll:write'] },
|
|
{ domain: 'documents', label: 'Dokument', scopes: ['documents:read', 'documents:write'] },
|
|
{ domain: 'pending_operations', label: 'Stagade operationer', scopes: ['pending_operations:read', 'pending_operations:approve'] },
|
|
{ domain: 'agent', label: 'Agent', scopes: ['agent:read', 'agent:write'] },
|
|
{ domain: 'skatteverket', label: 'Skatteverket', scopes: ['skatteverket:write'] },
|
|
{ domain: 'compliance', label: 'Compliance', scopes: ['compliance:read'] },
|
|
{ domain: 'events', label: 'Händelser', scopes: ['events:read'] },
|
|
{ domain: 'webhooks', label: 'Webhooks', scopes: ['webhooks:manage'] },
|
|
{ domain: 'operations', label: 'Operationer', scopes: ['operations:read'] },
|
|
]
|
|
|
|
/**
|
|
* Read scopes are the implicit baseline; everything else (write, manage,
|
|
* approve, signoff) is an elevated grant and is rendered as such.
|
|
*/
|
|
export function scopeKind(scope: ApiKeyScope): 'read' | 'write' {
|
|
return scope.endsWith(':read') ? 'read' : 'write'
|
|
}
|
|
|
|
/** Map MCP tool name → required scope. Tools omitted from this map are available to any authenticated key (e.g. discovery/search/skill loading). */
|
|
export const TOOL_SCOPE_MAP: Record<string, ApiKeyScope> = {
|
|
// Companies
|
|
gnubok_list_companies: 'companies:read',
|
|
gnubok_create_company: 'companies:write',
|
|
gnubok_lookup_company: 'companies:read',
|
|
gnubok_connect_bank: 'companies:read',
|
|
gnubok_connect_skatteverket: 'companies:read',
|
|
gnubok_connect_migration: 'companies:read',
|
|
gnubok_get_company_settings: 'companies:read',
|
|
gnubok_update_company_settings: 'companies:write',
|
|
// Transactions
|
|
gnubok_list_uncategorized_transactions: 'transactions:read',
|
|
gnubok_list_cash_accounts: 'transactions:read',
|
|
gnubok_list_transactions_without_documents: 'transactions:read',
|
|
gnubok_create_transactions: 'transactions:write',
|
|
gnubok_categorize_transaction: 'transactions:write',
|
|
gnubok_ignore_transaction: 'transactions:write',
|
|
gnubok_receipt_matcher: 'transactions:write',
|
|
gnubok_get_counterparty_templates: 'transactions:read',
|
|
gnubok_suggest_categories: 'transactions:read',
|
|
gnubok_match_transaction_to_invoice: 'transactions:write',
|
|
gnubok_link_transaction_to_journal_entry: 'transactions:write',
|
|
gnubok_match_batch_allocate: 'transactions:write',
|
|
// Reconciliation (account-keyed). gnubok_get_reconciliation_status keeps its
|
|
// historical reports:read so existing keys are not cut off.
|
|
gnubok_list_reconciliation_items: 'reconciliation:read',
|
|
gnubok_reconcile_match: 'reconciliation:write',
|
|
gnubok_reconcile_unmatch: 'reconciliation:write',
|
|
gnubok_reconcile_signoff: 'reconciliation:signoff',
|
|
// Residual booking writes a verifikat: the same scope that books a bank row.
|
|
gnubok_reconcile_residual: 'transactions:write',
|
|
gnubok_bulk_book_transactions: 'transactions:write',
|
|
gnubok_bulk_book_inbox_items: 'transactions:write',
|
|
gnubok_auto_match_period: 'transactions:write',
|
|
// Skattekonto row booking writes a verifikat from an outside (SKV) row:
|
|
// same scope family as reconcile_residual / bulk_book above.
|
|
gnubok_book_skattekonto_row: 'transactions:write',
|
|
gnubok_book_skattekonto_rows: 'transactions:write',
|
|
// Customers
|
|
gnubok_list_customers: 'customers:read',
|
|
gnubok_create_customer: 'customers:write',
|
|
gnubok_update_customer: 'customers:write',
|
|
// Articles (artikelregister)
|
|
gnubok_list_articles: 'articles:read',
|
|
gnubok_create_article: 'articles:write',
|
|
gnubok_update_article: 'articles:write',
|
|
// Invoices
|
|
gnubok_list_invoices: 'invoices:read',
|
|
gnubok_get_invoice: 'invoices:read',
|
|
gnubok_get_invoice_deliveries: 'invoices:read',
|
|
gnubok_create_invoice: 'invoices:write',
|
|
gnubok_update_invoice: 'invoices:write',
|
|
gnubok_delete_draft_invoice: 'invoices:write',
|
|
gnubok_send_invoice: 'invoices:write',
|
|
gnubok_mark_invoice_as_paid: 'invoices:write',
|
|
gnubok_mark_invoice_as_sent: 'invoices:write',
|
|
// Recurring invoice schedules (staged template writes; no send/book at commit)
|
|
gnubok_list_recurring_schedules: 'invoices:read',
|
|
gnubok_create_recurring_schedule: 'invoices:write',
|
|
gnubok_update_recurring_schedule: 'invoices:write',
|
|
// Suppliers
|
|
gnubok_list_suppliers: 'suppliers:read',
|
|
gnubok_list_supplier_invoices: 'suppliers:read',
|
|
// Reports
|
|
gnubok_get_trial_balance: 'reports:read',
|
|
gnubok_get_vat_report: 'reports:read',
|
|
gnubok_vat_review_widget: 'reports:read',
|
|
gnubok_vat_close_check: 'reports:read',
|
|
gnubok_get_kpi_report: 'reports:read',
|
|
gnubok_get_income_statement: 'reports:read',
|
|
gnubok_list_accounts: 'reports:read',
|
|
// Kontoplan management: staged reference-data writes
|
|
gnubok_create_account: 'bookkeeping:write',
|
|
gnubok_update_account: 'bookkeeping:write',
|
|
// Verifikat annotation (notes-only edit: allowed on posted entries)
|
|
gnubok_set_voucher_note: 'bookkeeping:write',
|
|
gnubok_get_balance_sheet: 'reports:read',
|
|
gnubok_get_general_ledger: 'reports:read',
|
|
gnubok_query_journal: 'reports:read',
|
|
gnubok_get_ar_ledger: 'reports:read',
|
|
gnubok_get_supplier_ledger: 'reports:read',
|
|
gnubok_list_fiscal_periods: 'reports:read',
|
|
gnubok_get_reconciliation_status: 'reports:read',
|
|
gnubok_list_accrual_schedules: 'reports:read',
|
|
// Dimensions (kostnadsställe/projekt) registry: reads next to the report
|
|
// tools; the staged value-create is a bookkeeping write (dimensions PR3).
|
|
gnubok_list_dimensions: 'reports:read',
|
|
gnubok_list_dimension_values: 'reports:read',
|
|
gnubok_create_dimension_value: 'bookkeeping:write',
|
|
gnubok_get_dimension_pnl: 'reports:read',
|
|
// Staged bulk retag of posted-line dimensions (dimensions PR6).
|
|
gnubok_tag_journal_lines: 'bookkeeping:write',
|
|
// Document inbox
|
|
gnubok_create_document_upload: 'transactions:write',
|
|
gnubok_complete_document_upload: 'transactions:write',
|
|
gnubok_upload_document: 'transactions:write',
|
|
gnubok_list_inbox_items: 'transactions:read',
|
|
gnubok_get_inbox_item: 'transactions:read',
|
|
gnubok_list_unmatched_documents: 'transactions:read',
|
|
gnubok_get_document_content: 'transactions:read',
|
|
gnubok_attach_document_to_transaction: 'transactions:write',
|
|
gnubok_link_document_to_voucher: 'bookkeeping:write',
|
|
gnubok_link_documents_to_vouchers: 'bookkeeping:write',
|
|
// Körjournal (mileage): trip log reads/writes are payroll surface
|
|
// (milersättning, 7331); booking the verifikat is a journal write.
|
|
gnubok_list_mileage_trips: 'payroll:read',
|
|
gnubok_log_mileage_trip: 'payroll:write',
|
|
gnubok_book_mileage_period: 'bookkeeping:write',
|
|
// Payroll
|
|
gnubok_list_employees: 'payroll:read',
|
|
gnubok_get_salary_run: 'payroll:read',
|
|
gnubok_get_salary_journal: 'payroll:read',
|
|
gnubok_create_salary_run: 'payroll:write',
|
|
gnubok_calculate_salary_run: 'payroll:write',
|
|
gnubok_book_salary_run: 'payroll:write',
|
|
gnubok_generate_agi: 'payroll:write',
|
|
// Payroll gap-closure: reads + staged writes (1.6-1.8, 2.4)
|
|
gnubok_get_employee: 'payroll:read',
|
|
gnubok_get_payslip: 'payroll:read',
|
|
gnubok_list_absence: 'payroll:read',
|
|
gnubok_update_payslip_line: 'payroll:write',
|
|
gnubok_set_run_salary: 'payroll:write',
|
|
gnubok_update_salary_run: 'payroll:write',
|
|
gnubok_register_absence: 'payroll:write',
|
|
gnubok_delete_absence: 'payroll:write',
|
|
gnubok_create_employee: 'payroll:write',
|
|
gnubok_update_employee: 'payroll:write',
|
|
gnubok_set_employee_opening_balances: 'payroll:write',
|
|
gnubok_get_vacation_balance: 'payroll:read',
|
|
gnubok_close_vacation_year: 'payroll:write',
|
|
// Bookkeeping write (Stream 1 Phase 1): high-risk, always staged
|
|
gnubok_close_period: 'bookkeeping:write',
|
|
gnubok_lock_period: 'bookkeeping:write',
|
|
gnubok_unlock_period: 'bookkeeping:write',
|
|
gnubok_run_year_end: 'bookkeeping:write',
|
|
gnubok_post_kontantmetod_cutoff: 'bookkeeping:write',
|
|
gnubok_year_end_readiness: 'reports:read',
|
|
gnubok_set_opening_balances: 'bookkeeping:write',
|
|
gnubok_run_currency_revaluation: 'bookkeeping:write',
|
|
gnubok_explain_voucher_gap: 'bookkeeping:write',
|
|
gnubok_list_voucher_gaps: 'reports:read',
|
|
// Transaction reversal (medium-risk)
|
|
gnubok_uncategorize_transaction: 'transactions:write',
|
|
// SIE export (read-only) + import (write)
|
|
gnubok_export_sie: 'reports:read',
|
|
gnubok_audit_package: 'reports:read',
|
|
gnubok_import_sie: 'bookkeeping:write',
|
|
// Byte-exact SIE upload URL feeding gnubok_import_sie (same write intent).
|
|
gnubok_create_sie_upload: 'bookkeeping:write',
|
|
// Rot/rut begäran om utbetalning (records a payout request on generate)
|
|
gnubok_generate_rot_rut_file: 'invoices:write',
|
|
// Supplier CRUD
|
|
gnubok_create_supplier: 'suppliers:write',
|
|
// Supplier invoice lifecycle
|
|
gnubok_approve_supplier_invoice: 'suppliers:write',
|
|
gnubok_credit_supplier_invoice: 'suppliers:write',
|
|
gnubok_create_supplier_invoice_from_inbox: 'suppliers:write',
|
|
gnubok_set_inbox_extracted_data: 'suppliers:write',
|
|
// Supplier invoice payment via existing verifikat (no new bokföring)
|
|
gnubok_find_voucher_candidates_for_supplier_invoice: 'suppliers:read',
|
|
gnubok_link_supplier_invoice_to_voucher: 'suppliers:write',
|
|
// Invoice conversion + crediting
|
|
gnubok_convert_invoice: 'invoices:write',
|
|
gnubok_credit_invoice: 'invoices:write',
|
|
// Phase 4: arbitrary-line bookkeeping primitives (high-risk, always staged)
|
|
gnubok_create_voucher: 'bookkeeping:write',
|
|
gnubok_correct_entry: 'bookkeeping:write',
|
|
gnubok_reverse_journal_entry: 'bookkeeping:write',
|
|
// Agent surface (Phase 6 MCP parity): briefing tool exposes company-specific
|
|
// profile + memory so it's scoped; gnubok_list_skills / gnubok_load_skill
|
|
// stay unscoped (discovery + static Markdown bodies + globally-readable atom
|
|
// registry: no per-company data).
|
|
gnubok_get_agent_briefing: 'agent:read',
|
|
// Agent memory write (previously UNMAPPED → callable by any key). Mapping to
|
|
// agent:write; existing non-revoked keys are grandfathered in the
|
|
// 20260619140000 migration so this does not regress them.
|
|
gnubok_remember_fact: 'agent:write',
|
|
gnubok_forget_fact: 'agent:write',
|
|
// Pending operations approval (mirrors the /pending web UI)
|
|
gnubok_list_pending_operations: 'pending_operations:read',
|
|
gnubok_approve_pending_operation: 'pending_operations:approve',
|
|
gnubok_reject_pending_operation: 'pending_operations:approve',
|
|
// Skatteverket filing (PR5). Reads are compliance:read (status of moms/AGI);
|
|
// the two submit tools require the opt-in skatteverket:write staging scope.
|
|
gnubok_vat_declaration_validate: 'compliance:read',
|
|
gnubok_vat_declaration_status: 'compliance:read',
|
|
gnubok_agi_status: 'compliance:read',
|
|
gnubok_vat_declaration_submit: 'skatteverket:write',
|
|
gnubok_agi_submit: 'skatteverket:write',
|
|
|
|
// ── Audit retrofit (agent-native audit P0: unmapped = default-allow) ──
|
|
// These tools shipped without a scope mapping, making them callable by ANY
|
|
// authenticated key. Mapping them is accept-the-break by decision
|
|
// (2026-07-13): keys that relied on the default-allow hole lose access
|
|
// until granted the proper scope. Release-note callout required for the
|
|
// four WRITES below.
|
|
gnubok_link_invoice_to_voucher: 'invoices:write',
|
|
gnubok_undo_sie_import: 'bookkeeping:write',
|
|
gnubok_post_annual_depreciation: 'bookkeeping:write',
|
|
gnubok_import_rot_rut_beslut: 'invoices:write',
|
|
gnubok_list_verifikat_without_documents: 'transactions:read',
|
|
gnubok_find_voucher_candidates_for_invoice: 'invoices:read',
|
|
gnubok_propose_dispositioner: 'reports:read',
|
|
gnubok_propose_accruals: 'reports:read',
|
|
gnubok_propose_annual_depreciation: 'reports:read',
|
|
gnubok_preview_arsredovisning: 'reports:read',
|
|
gnubok_validate_arsredovisning: 'reports:read',
|
|
gnubok_list_arsredovisning_versions: 'reports:read',
|
|
gnubok_get_arsredovisning_filing_status: 'reports:read',
|
|
gnubok_preview_ef_declaration: 'reports:read',
|
|
// Deliberately UNSCOPED (available to any authenticated key):
|
|
// gnubok_search_tools, gnubok_list_skills, gnubok_load_skill,
|
|
// gnubok_feedback. Discovery + static skill bodies + feedback channel
|
|
// carry no per-company data; keeping them open is what lets an agent
|
|
// orient itself before its key's scopes are known.
|
|
}
|
|
|
|
/**
|
|
* Number of MCP tools gated by each scope, derived from TOOL_SCOPE_MAP at
|
|
* module load. 0 means the scope only gates REST endpoints. Never hand-write
|
|
* these numbers into labels: they drift the moment a tool is added.
|
|
*/
|
|
export const TOOL_COUNT_BY_SCOPE: Readonly<Record<ApiKeyScope, number>> = (() => {
|
|
const counts = Object.fromEntries(ALL_SCOPES.map((s) => [s, 0])) as Record<ApiKeyScope, number>
|
|
for (const scope of Object.values(TOOL_SCOPE_MAP)) counts[scope] += 1
|
|
return counts
|
|
})()
|