@arcforgelabs/flow 2026.11.5 → 2026.11.7

package/server/integrations/seazona/migrations/meta/_journal.json

@@ -57,6 +57,13 @@
       "when": 1792472936253,
       "tag": "0007_stage_moves",
       "breakpoints": true
+    },
+    {
+      "idx": 8,
+      "version": "7",
+      "when": 1794463203447,
+      "tag": "0008_order_remake",
+      "breakpoints": true
     }
   ]
 }

package/server/integrations/seazona/scheduler.js

@@ -85,14 +85,14 @@ export function createSeazonaScheduler({
     timer?.unref?.();
   }
 
-  async function tick() {
+  async function tick(options = {}) {
     timer = null;
     if (stopped) return;
     const startedAt = new Date(Number(now())).toISOString();
     const turn = { abandoned: false };
     const thisRun = (async () => {
       try {
-        const result = await run();
+        const result = await run(options);
         const failed = Object.entries(result.results).filter(([, lane]) => !lane.ok);
         last = { at: startedAt, ok: result.ok, lanes: Object.keys(result.results), failed: failed.map(([lane]) => lane) };
         report(result.results);
@@ -135,6 +135,17 @@ export function createSeazonaScheduler({
       nextRunAt = null;
       await running;
     },
+    // Sync now (server/core/sync-now.js): a person asks for a run now, with
+    // `options` (the lanes to read). While a run is going it starts nothing
+    // and answers 'running'. Otherwise the waiting run moves to now; the
+    // schedule goes on from its end as usual.
+    runNow(options = {}) {
+      if (stopped) return 'stopped';
+      if (running) return 'running';
+      if (timer) timers.clearTimeout(timer);
+      tick(options);
+      return 'started';
+    },
     status() {
       return { running: Boolean(running), nextRunAt, lastRun: last, stuckSince };
     },

package/server/integrations/seazona/schema.js

@@ -74,6 +74,8 @@ export const seazonaOrders = pgTable('seazona_orders', {
   lines: jsonb('lines').notNull().default([]),
   subtotalCents: cents('subtotal_cents'),
   patientReference: text('patient_reference'),
+  // Seazona's isRemake on the order: a remake of earlier work.
+  remake: boolean('remake').notNull().default(false),
   // Issue #12: Seazona answered 404. The row and its history stay; the order
   // reads as "Deleted in Seazona" and is out of billing. A later successful
   // read clears it.

package/server/integrations/seazona/settings.js

@@ -206,6 +206,9 @@ export function resolveSeazonaSettings(env = process.env) {
     // order number, for "Open in Seazona" on a stage move. Optional; one
     // without {ref} is ignored.
     orderUrlTemplate: orderUrlTemplate(env.SEAZONA_ORDER_URL),
+    // "Include in Sync now" (server/core/sync-now.js): on unless the lab
+    // turns it off.
+    syncNow: !['0', 'false', 'off', 'no'].includes(text(env.SEAZONA_SYNC_NOW).toLowerCase()),
   };
 
   if (mode === 'live' || mode === 'sandbox') {

package/server/integrations/seazona/store.js

@@ -81,6 +81,20 @@ export async function touchSynced(db, mirror, keys, { at }) {
   await db.update(table).set({ lastSyncedAt: at }).where(inArray(table[key], keys));
 }
 
+// The remake flag of orders whose other list fields did not change, from the
+// list rows (`flags`, Map(id -> boolean)): no detail read is needed. A change
+// counts as a change of the order, so the billing feed reads it again.
+export async function syncRemakeFlags(db, flags, { at }) {
+  const ids = [...flags.keys()];
+  if (!ids.length) return 0;
+  const values = ids.map((id) => flags.get(id) === true);
+  const { rowCount } = await db.execute(sql`
+    update seazona_orders o set remake = f.remake, last_changed_at = ${at}
+    from unnest(${sql.param(ids)}::text[], ${sql.param(values)}::boolean[]) as f(id, remake)
+    where o.id = f.id and o.remake is distinct from f.remake`);
+  return rowCount ?? 0;
+}
+
 // Issue #12: Seazona answered 404. Keep the row and its history, mark it, and
 // refresh its sync time so it never comes first in the rotation again. An
 // order seen in a list but never stored is kept from that list row.

package/server/integrations/seazona/sweep.js

@@ -17,6 +17,7 @@ import {
   readOrderFailures,
   readQuarantinedRecords,
   recordRecordFailure,
+  syncRemakeFlags,
   touchSynced,
   upsertRecords,
 } from './store.js';
@@ -129,8 +130,15 @@ function laneReadsFrom(state, sync) {
   return Number.isFinite(cursorMs) ? cursorMs - sync.cursorOverlapMs : null;
 }
 
-function isDue(progress, at, sync) {
+// What an orders cycle reads from each list row. 2: the remake flag
+// (Seazona's isRemake, migration 0008). A cycle that finished before Flow
+// kept the flag does not count, so the next run starts a new one and old
+// orders get their flag without waiting out SEAZONA_SWEEP_CYCLE_DAYS.
+export const ORDER_CYCLE_READS = 2;
+
+function isDue(progress, at, sync, kind) {
   if (progress?.cycleStartedAt) return true;
+  if (kind === 'orders' && (progress?.reads ?? 1) < ORDER_CYCLE_READS) return true;
   const finished = Date.parse(progress?.lastFinishedAt ?? '');
   return !Number.isFinite(finished) || at.getTime() - finished >= sync.sweepCycleMs;
 }
@@ -216,6 +224,8 @@ async function sweepOrderDay(ctx, day, progress, helpers, found) {
     }
   }
   await touchSynced(db, 'orders', unchanged, { at });
+  // The remake flag is on the list row: kept with no detail read.
+  await syncRemakeFlags(db, new Map(unchanged.map((id) => [id, listed.get(id)?.isRemake === true])), { at });
 
   // Held for this day, left out of the list, and not seen this cycle.
   for (const row of held) {
@@ -250,7 +260,7 @@ async function sweepOrders(ctx, cursor, helpers, found) {
     progress.days.shift();
     progress.checkedDays += 1;
   }
-  cursor.orders = { lastFinishedAt: at.toISOString(), checkedDays: progress.checkedDays };
+  cursor.orders = { lastFinishedAt: at.toISOString(), checkedDays: progress.checkedDays, reads: ORDER_CYCLE_READS };
 }
 
 // Clients and invoices: the whole list, then the held records it left out.
@@ -498,7 +508,7 @@ export async function runSweep(ctx, helpers) {
   try {
     for (const kind of SWEEP_KINDS) {
       if (budget.left <= 0) break;
-      if (!isDue(cursor[kind], at, sync)) continue;
+      if (!isDue(cursor[kind], at, sync, kind)) continue;
       if (kind === 'orders') await sweepOrders(sweepCtx, cursor, helpers, found);
       else await sweepWholeList(sweepCtx, kind, cursor, laneStates, helpers, found);
     }

package/server/integrations/sentry/index.js

@@ -1,6 +1,6 @@
 import * as SentryNode from '@sentry/node';
 import { isReplitWorkspace } from '../../core/host.js';
-import { scrubSpan } from '../../ui/monitoring.js';
+import { scrubEvent, scrubSpan } from '../../ui/monitoring.js';
 
 // The Sentry adapter (docs/SENTRY.md). It sends the errors Flow logs, the
 // browser's errors and problem reports, and performance traces from both
@@ -48,6 +48,7 @@ export const SENTRY_SETUP = {
     { name: 'SENTRY_ENVIRONMENT', label: 'Environment', advanced: true, help: 'How Sentry labels this installation, for example production. Empty: production, or workspace in a Replit workspace.' },
     { name: 'SENTRY_CLIENT', label: 'Client', advanced: true, help: 'The name your support desk files this installation\'s reports under. Sent as the client tag. Empty: no client tag.' },
     { name: 'SENTRY_FEEDBACK', label: 'Report button', kind: 'onoff', default: 'on', help: 'On: everyone signed in can send a report, with a screenshot, to this Sentry project.' },
+    { name: 'SENTRY_SCREENSHOT', label: 'Screenshot', kind: 'onoff', default: 'off', help: 'On: a report can add a screenshot. A screenshot shows the screen as it is, with names and prices, so it is off by default.' },
     { name: 'SENTRY_REPLAY', label: 'Replay', kind: 'onoff', default: 'on', help: 'On: each report and each browser error keeps up to the last minute of the page, as a replay with every word hidden.' },
     { name: 'SENTRY_TRACES_SAMPLE_RATE', label: 'Traces', advanced: true, help: 'The share of clicks, page loads and requests timed, from 0 (off) to 1 (all). Empty: 0.2.' },
   ],
@@ -61,6 +62,7 @@ export function readSentrySettings(env) {
   // labelled apart so they never read as the live app's.
   const environment = String(env.SENTRY_ENVIRONMENT ?? '').trim() || (isReplitWorkspace(env) ? 'workspace' : 'production');
   const feedback = String(env.SENTRY_FEEDBACK ?? 'on').trim() !== 'off';
+  const screenshot = String(env.SENTRY_SCREENSHOT ?? 'off').trim() === 'on';
   const replay = String(env.SENTRY_REPLAY ?? 'on').trim() !== 'off';
   const rate = String(env.SENTRY_TRACES_SAMPLE_RATE ?? '').trim();
   const tracesSampleRate = rate === '' ? DEFAULT_TRACES_SAMPLE_RATE : Number(rate);
@@ -72,7 +74,7 @@ export function readSentrySettings(env) {
   // Every event says which product and, when set, which client it is from,
   // so one support desk can serve many installations.
   const tags = client ? { product: 'flow', client } : { product: 'flow' };
-  return { dsn, environment, feedback, replay, tracesSampleRate, tags };
+  return { dsn, environment, feedback, screenshot, replay, tracesSampleRate, tags };
 }
 
 // No trace for the host's health check: it is not a person waiting.
@@ -105,8 +107,10 @@ export function createSentryAdapter({ sdk = SentryNode, env: hostEnv = process.e
         environment: settings.environment,
         release: release ?? undefined,
         initialScope: { tags: settings.tags },
-        // Flow sends what it logs; no request bodies, cookies or IP addresses.
+        // Flow sends what it logs, with private words masked (scrubEvent);
+        // no request bodies, cookies or IP addresses.
         sendDefaultPii: false,
+        beforeSend: scrubEvent,
         // A request the browser traced keeps the browser's choice, so a
         // click and the server work it caused stay one trace.
         tracesSampler: ({ attributes, inheritOrSampleWith }) => (
@@ -139,12 +143,13 @@ export function createSentryAdapter({ sdk = SentryNode, env: hostEnv = process.e
       // meant for browsers.
       browserMonitoring() {
         if (!settings) return null;
-        const { tracesSampleRate, replay } = settings;
+        const { tracesSampleRate, replay, screenshot } = settings;
         return {
           dsn: settings.dsn,
           environment: settings.environment,
           release,
           feedback: settings.feedback,
+          screenshot,
           replay,
           tags: settings.tags,
           tracesSampleRate,

package/server/integrations/setup.js

@@ -2,6 +2,8 @@ import { eq, sql } from 'drizzle-orm';
 import express from 'express';
 import { FlowError } from '../core/errors.js';
 import { deriveKey, openSecret, sealSecret } from '../core/secrets.js';
+import { startSyncNow, syncNowStatus } from '../core/sync-now.js';
+import { createActionGuard } from './call-guard.js';
 import { integrationSettingEvents, integrationSettings, organisations } from '../db/schema.js';
 
 // Integration setup in Settings (docs/INTEGRATIONS.md, "Set up in Flow"). An
@@ -183,8 +185,11 @@ export async function saveSettings(db, { adapter, secrets, actor, enabled, value
 
 // GET /api/integrations (owner): every adapter with settings, its state and
 // what is set. PUT /api/integrations/:id (owner): save and apply.
-export function createSetupRouter({ db, registry, personAuth, secrets, baseEnv = process.env, log = console }) {
+export function createSetupRouter({ db, registry, personAuth, secrets, baseEnv = process.env, log = console, buttonCooldowns = true }) {
   const router = express.Router();
+  // Sync now can call Xero at a press, so it is an action (docs/INTEGRATIONS.md,
+  // "Button presses"): one a minute, for all and for each integration alone.
+  const actions = createActionGuard({ integration: 'sync-now', actions: { syncNow: { cooldownMs: 60_000 } }, off: !buttonCooldowns });
   const owner = [personAuth.requireSession, personAuth.requireRole('owner')];
   // A change needs a verified owner sign-in, as connecting Xero does.
   const verifiedOwner = [personAuth.requireSession, personAuth.requireOwner];
@@ -205,6 +210,21 @@ export function createSetupRouter({ db, registry, personAuth, secrets, baseEnv =
     } catch (error) { next(error); }
   });
 
+  // Sync now (server/core/sync-now.js): what the button shows, and the
+  // press. Reads only; the reads stay inside each call guard.
+  router.get('/sync-now', ...owner, async (_req, res, next) => {
+    try {
+      res.json({ ok: true, integrations: await syncNowStatus(registry) });
+    } catch (error) { next(error); }
+  });
+  router.post('/sync-now', ...owner, express.json({ limit: '4kb' }), actions.route('syncNow', { key: (req) => req.body?.only ?? 'all' }), async (req, res, next) => {
+    try {
+      const only = req.body?.only ?? null;
+      if (only !== null && !registry.get(only)) return res.status(404).json({ ok: false, code: 'not_found', error: 'No such integration' });
+      res.json({ ok: true, results: await startSyncNow(registry, { only, actor: req.person.id, log }) });
+    } catch (error) { next(error); }
+  });
+
   router.put('/:id', ...verifiedOwner, express.json({ limit: '32kb' }), async (req, res) => {
     const adapter = registry.get(req.params.id);
     if (!adapter?.setup) return res.status(404).json({ ok: false, code: 'not_found', error: 'No such integration' });

package/server/integrations/xero/catalogue.js

@@ -223,6 +223,46 @@ export async function itemsByCode(db, organisationId, codes) {
   return new Map(rows.map((row) => [row.code, itemRow(row)]));
 }
 
+// The Xero item each Flow price code sends as. A Flow item linked to a Xero
+// item (the price list's link, by Xero's ItemID, so a code changed in Xero
+// still finds it) sends as that item, under Xero's own code. A link whose
+// Xero item has left Xero's list is `linkMissing`: never fall back to the
+// Flow code then. A Flow item with no link sends as the Xero item with the
+// same code. Codes with neither are absent from the map.
+export async function xeroItemsForCodes(db, organisationId, codes) {
+  const wanted = [...new Set(codes.filter(Boolean))];
+  if (!wanted.length) return new Map();
+  const { rows } = await db.execute(sql`
+    select p.code as flow_code, l.external_id as link_id, x.*
+    from unnest(${sql.param(wanted)}::text[]) as w(code)
+    left join price_items p on p.organisation_id = ${organisationId} and p.code = w.code
+    left join lateral (
+      select external_id from price_item_links pl
+      where pl.organisation_id = ${organisationId} and pl.price_item_id = p.id and pl.system = 'xero'
+      order by pl.created_at desc limit 1) l on true
+    left join xero_items x on x.organisation_id = ${organisationId}
+      and (case when l.external_id is not null then x.xero_item_id = l.external_id else x.code = w.code end)`);
+  const found = new Map();
+  for (const row of rows) {
+    const code = row.flow_code;
+    if (!code) continue;
+    if (row.link_id && !row.xero_item_id) found.set(code, { linkMissing: true, xeroItemId: row.link_id });
+    else if (row.xero_item_id) found.set(code, { ...itemRow(row), linked: Boolean(row.link_id) });
+  }
+  // A code with no Flow price item (an older document) still matches by code.
+  const rest = wanted.filter((c) => !found.has(c));
+  if (rest.length) for (const [code, item] of await itemsByCode(db, organisationId, rest)) found.set(code, item);
+  return found;
+}
+
+// The Flow codes that send as a Xero item that sells: the rule field "Every
+// item is in accounting" (invoice-rules.js) reads them. A gone link, a
+// missing item and an item not set to be sold do not count.
+export async function sellingCodes(db, organisationId, codes) {
+  const items = await xeroItemsForCodes(db, organisationId, codes);
+  return [...items].filter(([, item]) => !item.linkMissing && item.isSold !== false).map(([code]) => code);
+}
+
 // The Xero contact for a Flow contact name: exactly one active contact with
 // the same name, or why not. A missing name can be created from the Flow
 // contact when that setting is on (create-contact.js). A doubled name is

package/server/integrations/xero/drafts.js

@@ -5,7 +5,7 @@ import { getInvoice, listInvoiceVersions } from '../../core/invoices.js';
 import { sendModeFor } from '../../core/invoicing-rules.js';
 import { contacts as flowContacts, invoices as flowInvoices, priceItems } from '../../db/schema.js';
 import { readConnection } from './connections.js';
-import { itemsByCode, lastSuccessfulSyncAt, matchContactFor, normaliseName } from './catalogue.js';
+import { lastSuccessfulSyncAt, xeroItemsForCodes, matchContactFor, normaliseName } from './catalogue.js';
 import { writesAllowed } from './settings.js';
 import { xeroError } from './client.js';
 import { withXeroLane } from './governor.js';
@@ -162,8 +162,19 @@ export function buildDraft(document, { settings, contact, items, sendMode = 'acc
       TaxType: settings.taxTypes[line.taxCode],
     };
     if (line.itemCode) {
-      if (items.has(line.itemCode)) out.ItemCode = line.itemCode;
-      else problems.push(problem('xero_item_missing', `Line ${line.position}: item ${line.itemCode} is not in Xero. Add it in Xero, then sync.`, { itemCode: line.itemCode, short: `${line.itemCode} not in Xero` }));
+      // The Xero item this Flow code sends as (catalogue.js, xeroItemsForCodes):
+      // the linked item under Xero's own code, else the same code.
+      const item = items.get(line.itemCode);
+      if (item?.linkMissing) {
+        problems.push(problem('xero_item_missing', `Line ${line.position}: item ${line.itemCode} is linked to a Xero item that is no longer in Xero. Link it again in Price list, then sync.`, { itemCode: line.itemCode, short: `${line.itemCode} link gone` }));
+      } else if (!item) {
+        problems.push(problem('xero_item_missing', `Line ${line.position}: item ${line.itemCode} is not in Xero. Add it in Xero, then sync.`, { itemCode: line.itemCode, short: `${line.itemCode} not in Xero` }));
+      } else if (item.isSold === false) {
+        problems.push(problem('xero_item_missing', `Line ${line.position}: Xero item ${item.code || line.itemCode} is not set to be sold. Turn on "I sell this item" in Xero, then sync.`, { itemCode: line.itemCode, short: `${item.code || line.itemCode} not sold in Xero` }));
+      } else {
+        out.ItemCode = item.code || line.itemCode;
+        if (settings.lineText === 'item' && item.name) out.Description = item.name;
+      }
     } else if (line.accountCode) {
       // A line with no item books to its own account, such as a surcharge.
       out.AccountCode = line.accountCode;
@@ -324,7 +335,7 @@ async function previewOne(db, runtime, organisationId, invoiceId) {
   const offerCreate = match.state === 'missing' && runtime.settings.createContacts && writesAllowed(runtime.settings);
   if (match.state === 'missing') problems.push(missingContact(document.contact.name, { offerCreate }));
   if (match.state === 'ambiguous') problems.push(twiceContact(document.contact.name));
-  const items = await itemsByCode(db, organisationId, document.lines.map((l) => l.itemCode));
+  const items = await xeroItemsForCodes(db, organisationId, document.lines.map((l) => l.itemCode));
   const sendMode = await sendModeFor(db, organisationId, invoice.contactId);
   const { draft, problems: lineProblems } = buildDraft(document, { settings: runtime.settings, contact: match.contact, items, sendMode });
   problems.push(...lineProblems);
@@ -509,7 +520,7 @@ async function pushOne(db, runtime, client, organisationId, invoiceId, { pushedB
     const found = match.state === 'missing' ? missingContact(document.contact.name, { offerCreate }) : twiceContact(document.contact.name);
     throw xeroError(found.code, found.message, { status: 409, short: found.short });
   }
-  const items = await itemsByCode(db, organisationId, document.lines.map((l) => l.itemCode));
+  const items = await xeroItemsForCodes(db, organisationId, document.lines.map((l) => l.itemCode));
   const sendMode = await sendModeFor(db, organisationId, invoice.contactId);
   const { draft, problems } = buildDraft(document, { settings: runtime.settings, contact: match.contact, items, sendMode });
   if (problems.length) throw xeroError(problems[0].code, problems.map((p) => p.message).join(' '), { status: 409, short: problems[0].short });

package/server/integrations/xero/index.js

@@ -7,6 +7,7 @@ import { deleteXeroInvoice } from './delete-invoice.js';
 import { createCustomer } from './create-contact.js';
 import { checkDrafts, documentFacts, pushInvoice, pushInvoices } from './drafts.js';
 import { readConnection } from './connections.js';
+import { lastSuccessfulSyncAt, sellingCodes } from './catalogue.js';
 import { createImportWorker } from './import.js';
 import { readPayments, xeroLiveCheck } from './ledger.js';
 import { findInvoices, listCustomers, listPriceItems, mirrorState } from './lookup.js';
@@ -47,6 +48,7 @@ export const XERO_SETUP = {
     { name: 'XERO_TENANT_NAME', label: 'Xero organisation name', help: 'Live mode connects only the organisation with this exact name.' },
     { name: 'XERO_ALLOW_LIVE_WRITES', label: 'Create draft invoices in live Xero', kind: 'onoff', help: 'Off: Flow only reads from Xero.' },
     { name: 'XERO_CREATE_CONTACTS', label: 'Create missing clients', kind: 'onoff', default: 'on', help: 'On: a pending invoice whose client is not in Xero offers Create. Off: add the client in Xero, then sync.' },
+    { name: 'XERO_SYNC_NOW', label: 'Include in Sync now', kind: 'onoff', default: 'on', help: 'On: Sync now on the Integrations page also reads Xero\'s changed invoices and credit notes. Each uses a few of the day\'s Xero calls.' },
     { name: 'XERO_WEBHOOK_KEY', label: 'Webhook key', secret: true, help: 'From the Xero app\'s Webhooks page. Empty: Flow reads Xero\'s changes every 15 minutes instead.' },
   ],
   derivedKeys: ['XERO_TOKEN_KEY'],
@@ -159,6 +161,30 @@ export function createXeroAdapter({ runtime: given = null } = {}) {
       // Xero's latest changes into the copy just before Flow drafts by rule or
       // sends (webhooks.js); no call when the copy is current.
       readChanges: ({ organisationId }) => readChangesFirst(database, current(), organisationId),
+      // Sync now (server/core/sync-now.js): Xero's latest invoice and credit
+      // note changes into the copy now, for each connected organisation, even
+      // when the copy counts as current. Off while "Include in Sync now" is off,
+      // unless a person asked for Xero alone (`asked`, its own Sync button).
+      syncNow: async ({ asked = false } = {}) => {
+        const { settings } = current();
+        if (!settings.syncNow && !asked) return { state: 'off' };
+        const { rows } = await database.execute(sql`select organisation_id from xero_connections where mode = ${settings.mode}`);
+        if (!rows.length) return { state: 'unavailable', reason: 'Xero is not connected' };
+        let changed = 0;
+        for (const row of rows) {
+          const answer = await readChangesFirst(database, current(), row.organisation_id, { force: true });
+          if (answer.state === 'unavailable') return answer;
+          changed += answer.changed ?? 0;
+        }
+        return { state: 'read', changed };
+      },
+      syncNowStatus: async () => {
+        const { settings } = current();
+        const { rows: [row] } = await database.execute(sql`select max(c.last_read_at) as at from xero_mirror_cursors c
+          join xero_connections x on x.organisation_id = c.organisation_id and x.mode = ${settings.mode}
+          where c.resource = 'invoices'`);
+        return { included: settings.syncNow, running: false, lastAt: row?.at ? new Date(row.at).toISOString() : null, ok: null };
+      },
       // Active Xero contacts, from Flow's copy (lookup.js).
       listCustomers: ({ organisationId }) => listCustomers(database, organisationId),
       // Create the Xero contact for one Flow contact, when that setting is on
@@ -166,6 +192,15 @@ export function createXeroAdapter({ runtime: given = null } = {}) {
       createCustomer: ({ organisationId, contactId, actor = null }) => createCustomer(database, current(), { organisationId, contactId, actor }),
       // Sales invoices from the mirror, with the mirror's state (lookup.js).
       findInvoices: ({ organisationId, ...query }) => findInvoices(database, organisationId, query),
+      // The Flow codes that send as a Xero item that sells (catalogue.js),
+      // for the invoice rule field "Every item is in accounting". Null while
+      // not connected or before the first item sync.
+      itemMatches: async ({ organisationId, codes = [] }) => {
+        const connection = await readConnection(database, organisationId);
+        if (!connection || connection.mode !== current().settings.mode) return null;
+        if (!(await lastSuccessfulSyncAt(database, organisationId))) return null;
+        return sellingCodes(database, organisationId, codes);
+      },
       // Xero items, from Flow's copy, for the price list (lookup.js).
       listPriceItems: ({ organisationId }) => listPriceItems(database, organisationId, { taxTypes: current().settings.taxTypes }),
     },

package/server/integrations/xero/lookup.js

@@ -107,7 +107,8 @@ function invoiceRow(r) {
 }
 
 // Sales invoices from the mirror, by any of: Xero ids, invoice numbers, the
-// Flow invoices Flow sent, or one customer within a date range. Answers the
+// Flow invoices Flow sent or the Xero import linked, or one customer within a
+// date range. Answers the
 // mirror's state with them, and the latest change time it holds.
 export async function findInvoices(db, organisationId, query = {}) {
   const { invoiceIds = [], numbers = [], references = [], flowInvoiceIds = [], contactId = null, from = null, to = null } = query;
@@ -127,9 +128,15 @@ export async function findInvoices(db, organisationId, query = {}) {
     select i.*, p.invoice_id as flow_invoice_id
     from xero_invoices i
     left join lateral (
-      select invoice_id from xero_invoice_pushes
-      where organisation_id = i.organisation_id and xero_invoice_id = i.xero_invoice_id
-      order by version desc limit 1
+      -- The Flow invoice this Xero invoice is: the one Flow sent it from,
+      -- else the one the Xero import linked or made from it.
+      select invoice_id from (
+        select invoice_id, 0 as pick, version from xero_invoice_pushes
+        where organisation_id = i.organisation_id and xero_invoice_id = i.xero_invoice_id
+        union all
+        select invoice_id, 1, 0 from xero_invoice_links
+        where organisation_id = i.organisation_id and xero_invoice_id = i.xero_invoice_id
+      ) f order by pick, version desc limit 1
     ) p on true
     where i.organisation_id = ${organisationId} and i.type = 'ACCREC'
       and (${sql.join(where, sql` or `)})

package/server/integrations/xero/settings.js

@@ -163,6 +163,8 @@ export function resolveXeroSettings(env = process.env) {
 
   const invoiceNumber = (readEnv(env, 'XERO_INVOICE_NUMBER') || 'xero').toLowerCase();
   if (!['xero', 'flow'].includes(invoiceNumber)) throw new Error('XERO_INVOICE_NUMBER must be "xero", "flow" or unset');
+  const lineText = (readEnv(env, 'XERO_LINE_TEXT') || 'flow').toLowerCase();
+  if (!['flow', 'item'].includes(lineText)) throw new Error('XERO_LINE_TEXT must be "flow", "item" or unset');
 
   return {
     mode,
@@ -184,6 +186,9 @@ export function resolveXeroSettings(env = process.env) {
     tracking: resolveTracking(env),
     defaultDueDays: readPositiveInteger(env, 'XERO_DEFAULT_DUE_DAYS', DEFAULT_DUE_DAYS),
     invoiceNumber,
+    // The text on each Xero line with an item: `flow` (default) the Flow
+    // line's own text; `item` the Xero item's name.
+    lineText,
     replayFixtures: readEnv(env, 'XERO_REPLAY_FIXTURES') || null,
     // Free text on Xero records (references, line descriptions) is the lab's
     // own data, and the Import matches on it. On unless the lab turns it off.
@@ -191,6 +196,9 @@ export function resolveXeroSettings(env = process.env) {
     // On unless the lab turns it off: a pending invoice whose client is not
     // in Xero offers to create that client (docs/CONTACTS.md).
     createContacts: readOnOff(env, 'XERO_CREATE_CONTACTS', true),
+    // On unless the lab turns it off: Sync now (server/core/sync-now.js) also
+    // reads Xero's changes. Each Sync now costs a few of the day's calls.
+    syncNow: readOnOff(env, 'XERO_SYNC_NOW', true),
     mirrorPageSize: Math.min(readPositiveInteger(env, 'XERO_MIRROR_PAGE_SIZE', DEFAULT_MIRROR_PAGE_SIZE), MAX_MIRROR_PAGE_SIZE),
     // The share of the day's calls the mirror leaves for drafts and people.
     mirrorReserveFraction: readFraction(env, 'XERO_MIRROR_RESERVE_FRACTION', 0.3),

package/server/integrations/xero/webhooks.js

@@ -272,16 +272,17 @@ export async function dueDailyChecks(db, runtime, { now = Date.now() } = {}) {
 //   unavailable  the read could not run (`reason`); act on nothing
 export const READ_FIRST_MS = 10 * 60 * 1000;
 
-export async function readChangesFirst(db, runtime, organisationId, { now = Date.now } = {}) {
+// `force` (Sync now) reads even when the copy counts as current.
+export async function readChangesFirst(db, runtime, organisationId, { now = Date.now, force = false } = {}) {
   const { rows: [connection] } = await db.execute(sql`select tenant_id from xero_connections
     where organisation_id = ${organisationId} and mode = ${runtime.settings.mode}`);
   if (!connection) return { state: 'unavailable', reason: 'Xero is not connected' };
   const { rows: [{ waiting }] } = await db.execute(sql`select count(*)::int as waiting from xero_webhook_events
     where organisation_id = ${organisationId} and pending`);
-  if (!waiting && await webhooksActive(db, runtime, organisationId, { now: Number(now()) })) return { state: 'fresh' };
+  if (!force && !waiting && await webhooksActive(db, runtime, organisationId, { now: Number(now()) })) return { state: 'fresh' };
   const { rows: [{ oldest }] } = await db.execute(sql`select min(last_read_at) as oldest from xero_mirror_cursors
     where organisation_id = ${organisationId} and resource in ('invoices', 'credit_notes')`);
-  if (!waiting && oldest && Number(now()) - new Date(oldest).getTime() <= READ_FIRST_MS) return { state: 'fresh' };
+  if (!force && !waiting && oldest && Number(now()) - new Date(oldest).getTime() <= READ_FIRST_MS) return { state: 'fresh' };
   try {
     const inbox = await readInbox(db, runtime, organisationId, { now });
     if (inbox.stopped) return { state: 'unavailable', reason: inbox.stopped === 'budget' ? 'the day\'s Xero calls are kept for people' : 'Xero calls are stopped' };

package/server/ui/app.js

@@ -640,6 +640,50 @@ function integrationLogo(integration, size = '') {
     file ? h('img', { src: `/assets/ui/logos/${file}`, alt: '' }) : icon('plug'));
 }
 
+// Sync now (server/core/sync-now.js): reads each integration whose "Include
+// in Sync now" setting is on, now. With `only`, it is that integration's own
+// Sync on its page, and reads it whatever the setting says. Which ones, and
+// when the last read started, are on hover. While a read goes on, the button
+// says so and asks Flow again every 5 seconds (Flow's data only). Hidden while
+// nothing it would read can sync.
+function syncNowButton({ only = null } = {}) {
+  const word = only ? 'Sync' : 'Sync now';
+  const button = h('button', { class: 'fx-btn', type: 'button', hidden: true, disabled: true }, word);
+  const when = (at) => new Date(at).toLocaleString('en-AU', { dateStyle: 'medium', timeStyle: 'short' });
+  let timer = null;
+  const show = (all) => {
+    const list = only ? all.filter((i) => i.id === only) : all;
+    const included = only ? list : list.filter((i) => i.included);
+    const running = included.some((i) => i.running);
+    const last = included.map((i) => i.lastAt).filter(Boolean).sort().pop();
+    button.hidden = !list.length;
+    button.disabled = running || !included.length;
+    button.replaceChildren(...(running ? [h('span', { class: 'fx-spinner fx-spinner--sm', 'aria-hidden': 'true' }), 'Syncing'] : [word]));
+    button.title = included.length
+      ? `Reads ${included.map((i) => i.name).join(' and ')}.${last ? ` Last read ${when(last)}.` : ''}`
+      : 'Turn on "Include in Sync now" in an integration\'s settings.';
+    clearTimeout(timer);
+    if (running) timer = setTimeout(() => { if (button.isConnected) load(); }, 5000);
+  };
+  const load = () => flow('/api/integrations/sync-now')
+    .then(({ integrations }) => show(integrations))
+    .catch(() => { button.hidden = true; });
+  button.addEventListener('click', async () => {
+    button.disabled = true;
+    try {
+      const { results } = await flow('/api/integrations/sync-now', { method: 'POST', body: JSON.stringify(only ? { only } : {}) });
+      for (const r of results.filter((r) => r.state === 'unavailable')) toast(`${r.name}: ${r.reason}`, 'danger');
+      const reading = results.filter((r) => ['started', 'running', 'read'].includes(r.state));
+      if (reading.length) toast(`Reading ${reading.map((r) => r.name).join(' and ')}.`, 'success');
+    } catch (error) {
+      toast(error.message, 'danger');
+    }
+    load();
+  });
+  load();
+  return button;
+}
+
 async function renderIntegrations(main) {
   const state = { tab: 'all', category: 'all', q: '' };
   const tabs = h('div', { class: 'fx-seg', role: 'tablist' });
@@ -649,7 +693,7 @@ async function renderIntegrations(main) {
   const notices = h('div', { class: 'fx-fields' });
   const content = h('div', { class: 'fx-int-sections' }, h('div', { class: 'fx-skeleton' }));
   main.append(
-    pageHeader('Integrations'),
+    pageHeader('Integrations', { actions: [syncNowButton()] }),
     alertStrip(ui(), 'integrations').element,
     h('div', { class: 'fx-int-bar' }, tabs, h('div', { class: 'fx-row' }, category, search)),
     notices, content);
@@ -848,6 +892,18 @@ async function renderIntegration(main, id) {
       }
     };
 
+    // A disconnect stops the integration, so it asks first: one stray click
+    // must not stop a lab's sync.
+    const disconnect = async () => {
+      const ok = await dialog({
+        title: `Disconnect ${current.name}?`,
+        body: h('p', {}, `Flow stops working with ${current.name} until someone connects it again. Its settings and Flow's records stay.`),
+        confirm: 'Disconnect',
+        tone: 'danger',
+      });
+      if (ok) await save(false);
+    };
+
     const on = current.enabled;
     const guide = current.guide;
     const hostOwned = current.enabledBy === 'host';
@@ -855,10 +911,13 @@ async function renderIntegration(main, id) {
     const modeLabel = mode?.choices?.find((c) => c.value === mode.value)?.label ?? mode?.value;
     const busy = progress && progress.steps.some((step) => step.state === 'running');
 
-    const primary = !canChange || hostOwned ? null : on
-      ? h('button', { class: 'fx-btn', type: 'button', onclick: () => save(false) }, 'Disconnect')
+    const primary = !canChange || hostOwned || on ? null
       : h('button', { class: 'fx-btn fx-btn--primary', type: 'button', disabled: busy, onclick: connect },
         busy ? h('span', { class: 'fx-spinner fx-spinner--sm', 'aria-hidden': 'true' }) : null, busy ? 'Connecting' : 'Connect');
+    // Disconnect sits at the end of the page, away from Sync.
+    const disconnectRow = !canChange || hostOwned || !on ? null
+      : h('div', { class: 'fx-int-section' }, h('div', { class: 'fx-row fx-row--end' },
+        h('button', { class: 'fx-btn fx-btn--ghost fx-btn--danger', type: 'button', onclick: disconnect }, 'Disconnect')));
 
     host.replaceChildren(
       crumbs(['/integrations', 'Integrations'], current.name),
@@ -869,6 +928,7 @@ async function renderIntegration(main, id) {
             h('h1', { class: 'fx-title' }, current.name),
             h('div', { class: 'fx-int-hero__actions' },
               on ? statusPill(current) : null,
+              on && current.state === 'ready' ? syncNowButton({ only: current.id }) : null,
               primary,
               progress ? connectProgress(progress) : null)),
           alerts.element,
@@ -893,6 +953,7 @@ async function renderIntegration(main, id) {
               h('summary', {}, 'Advanced'),
               h('div', { class: 'fx-settings' }, advanced)) : null,
             canChange && on && inputs.size ? h('div', { class: 'fx-row fx-row--end' }, h('button', { class: 'fx-btn', type: 'button', onclick: () => save(undefined) }, 'Save changes')) : null) : null,
+          disconnectRow,
         ].filter(Boolean)),
         h('aside', { class: 'fx-int-page__meta' },
           h('dl', { class: 'fx-meta' }, ...[

package/server/ui/flow.css

@@ -1888,7 +1888,8 @@ body[data-state="loading"] .fx-loading { display: grid; justify-items: center; }
   content: ''; position: absolute; top: 3px; left: 3px; width: 16px; height: 16px;
   border-radius: 50%; background: var(--t-paper); transition: transform 0.15s;
 }
-.fx-switch[aria-checked="true"] { background: var(--t-primary); }
+/* background-color only: the shorthand would reset background-clip and fill the touch border. */
+.fx-switch[aria-checked="true"] { background-color: var(--t-primary); }
 .fx-switch[aria-checked="true"]::after { transform: translateX(18px); }
 .fx-switch:focus-visible { outline: none; box-shadow: var(--fx-focus); }
 .fx-switch:disabled { cursor: default; opacity: 0.6; }

package/server/ui/kit.js

@@ -244,7 +244,7 @@ export function dialog({ title, body, confirm, tone = 'primary', choices = null
       h('h2', { class: 'fx-dialog__title' }, title),
       choiceList ?? body,
       actions);
-    const element = applyPhoneRule(h('dialog', { class: 'fx-dialog' }, form), 'dialog');
+    const element = applyPhoneRule(h('dialog', { class: 'fx-dialog', 'aria-label': title }, form), 'dialog');
     element.addEventListener('close', () => {
       const value = element.returnValue;
       element.remove();
@@ -258,7 +258,8 @@ export function dialog({ title, body, confirm, tone = 'primary', choices = null
     if (choices) element.addEventListener('click', (event) => { if (event.target === element) element.close(); });
     document.body.append(element);
     element.showModal();
-    element.querySelector(choices ? '.fx-sheet__choice' : 'input, select, button[value="ok"]')?.focus();
+    // A danger step starts on Cancel, so Enter or a second tap does not confirm it.
+    element.querySelector(choices ? '.fx-sheet__choice' : `input, select, button[value="${tone === 'danger' ? 'cancel' : 'ok'}"]`)?.focus();
   });
 }