@teincfood/core 0.10.4 → 0.10.6

package/dist/adapters/devices.d.ts

@@ -2,6 +2,15 @@
  * Devices service — stable per-device UUID for DD lease.
  * Persists via KV sync so DD stays same for life of device (until wipe).
  */
+export interface DeviceMetadata {
+    deviceName?: string | null;
+    platform?: string | null;
+    osVersion?: string | null;
+    appVersion?: string | null;
+}
+/** Host apps inject OS/device details so licenses and admin dashboards can identify terminals. */
+export declare function setDeviceMetadataProvider(provider: (() => Promise<DeviceMetadata> | DeviceMetadata) | null): void;
+export declare function getDeviceMetadata(): Promise<DeviceMetadata>;
 export declare function setAppInstanceId(id: string): void;
 export declare function getAppInstanceId(): string;
 export declare function getAppInstanceIdAsync(): Promise<string>;

package/dist/adapters/devices.js

@@ -6,6 +6,21 @@ import { getItemSync, setItemSync, getItem, setItem } from "./kv";
 import { generateUUID } from "../utils/uuid";
 let appInstanceId = null;
 const APP_ID_KEY = "teinc_app_instance_id";
+let deviceMetadataProvider = null;
+/** Host apps inject OS/device details so licenses and admin dashboards can identify terminals. */
+export function setDeviceMetadataProvider(provider) {
+    deviceMetadataProvider = provider;
+}
+export async function getDeviceMetadata() {
+    if (!deviceMetadataProvider)
+        return {};
+    try {
+        return await deviceMetadataProvider();
+    }
+    catch {
+        return {};
+    }
+}
 // For Tauri desktop, try to restore from localStorage synchronously at import to avoid async race generating a new UUID on every cargo tauri dev restart
 try {
     if (typeof localStorage !== "undefined") {

package/dist/hooks/members.hooks.js

@@ -10,6 +10,7 @@ import { getAuthToken, subscribeAuth } from "../adapters/auth";
 import { businessService, rolesService, fleetService } from "../adapters/services";
 import { assertOnlineFor } from "../sync/online-gates";
 import { runOfflineCapableMutation } from "../sync/offline-capable";
+import { removeOfflineMember, updateOfflineMemberRole } from "../offline/store";
 import { validateInviteInput } from "../validation/offline";
 import { notifySuccess, notifyError } from "../adapters/notify";
 import { extractApiErrorMessage } from "../utils/error";
@@ -106,7 +107,12 @@ export function useRemoveMemberMutation() {
                 payload: { user_id: userId },
             });
         },
-        onSuccess: (result) => {
+        onSuccess: async (result, userId) => {
+            // Revoke local offline access immediately, even when the server command
+            // is queued. Otherwise a removed member can still unlock this terminal.
+            if (businessId) {
+                await removeOfflineMember(userId, businessId).catch(() => undefined);
+            }
             notifySuccess(isQueued(result) ? "Member removal queued" : "Member removed");
             queryClient.invalidateQueries({ queryKey: MEMBER_KEYS.list(businessId ?? "") });
             if (businessId)
@@ -133,7 +139,10 @@ export function useUpdateMemberRoleMutation() {
                 payload,
             });
         },
-        onSuccess: (result) => {
+        onSuccess: async (result, variables) => {
+            if (businessId && variables.role) {
+                await updateOfflineMemberRole(variables.userId, businessId, variables.role).catch(() => undefined);
+            }
             notifySuccess(isQueued(result) ? "Role change queued" : "Member role updated");
             queryClient.invalidateQueries({ queryKey: MEMBER_KEYS.list(businessId ?? "") });
             if (businessId)

package/dist/offline/service.d.ts

@@ -50,6 +50,9 @@ export declare function activateOfflineDevice(args: {
     pin: string;
     appInstanceId?: string;
     platform?: string;
+    deviceName?: string;
+    osVersion?: string;
+    appVersion?: string;
 }): Promise<OfflineActivationResult>;
 /** Refresh the signed license while online using the normal access token. */
 export declare function refreshOfflineLicense(businessId: string): Promise<OfflineActivationResult>;
@@ -78,6 +81,16 @@ export declare function revokeMemberOnDevice(args: {
 }): Promise<void>;
 /** Owner action: revoke the terminal and wipe all local offline credentials. */
 export declare function removeOfflineDevice(businessId: string, reason?: string): Promise<void>;
+/**
+ * Best-effort presence heartbeat. Updates the admin dashboard's last-seen and
+ * online state; never throws into app startup or sync loops.
+ */
+export declare function sendOfflineDeviceHeartbeat(businessId: string, overrides?: {
+    deviceName?: string;
+    platform?: string;
+    osVersion?: string;
+    appVersion?: string;
+}): Promise<void>;
 export declare function getStoredOfflineLicensePayload(businessId?: string): Promise<OfflineLicensePayload | null>;
 export declare function evaluateStoredOfflineLicense(businessId?: string): Promise<OfflineLicenseEvaluation>;
 export { evaluateOfflineLicense };

package/dist/offline/service.js

@@ -5,9 +5,10 @@
  * verify the signed license, unlock enrolled members locally, and only needs
  * the network to exchange the device challenge for fresh session tokens.
  */
-import { getAppInstanceIdAsync } from "../adapters/devices";
+import { getAppInstanceIdAsync, getDeviceMetadata } from "../adapters/devices";
 import { getHttpClient } from "../adapters/http";
 import { getAuthToken } from "../adapters/auth";
+import { getConnectivityState } from "../adapters/connectivity";
 import { syncLogger } from "../utils/sync-logger";
 import { offlineRandomBytes } from "./random";
 import { base64UrlDecode, base64UrlEncode, canonicalDeviceChallenge, decodeLicensePayload, evaluateOfflineLicense, generateOfflineDeviceKeypair, loadAndVerifyOfflineLicense, newOfflineNonce, signDeviceChallenge, verifyOfflineLicense, } from "./license";
@@ -35,11 +36,15 @@ export async function activateOfflineDevice(args) {
     if (!getAuthToken())
         throw new Error("Sign in online before activating this device");
     const deviceId = args.appInstanceId ?? (await getAppInstanceIdAsync());
+    const metadata = await getDeviceMetadata();
     const keypair = await generateOfflineDeviceKeypair(randomBytes);
     const response = await getHttpClient().post(`/businesses/${args.businessId}/devices/${encodeURIComponent(deviceId)}/activate`, {
         device_public_key: keypair.publicKeyB64,
         app_instance_id: deviceId,
-        platform: args.platform ?? "unknown",
+        platform: args.platform ?? metadata.platform ?? "unknown",
+        device_name: args.deviceName ?? metadata.deviceName ?? undefined,
+        os_version: args.osVersion ?? metadata.osVersion ?? undefined,
+        app_version: args.appVersion ?? metadata.appVersion ?? undefined,
     });
     const data = response.data.data;
     if (!data?.license || !data.public_key) {
@@ -191,6 +196,30 @@ export async function removeOfflineDevice(businessId, reason) {
     }
     await clearOfflineDevice(businessId);
 }
+/**
+ * Best-effort presence heartbeat. Updates the admin dashboard's last-seen and
+ * online state; never throws into app startup or sync loops.
+ */
+export async function sendOfflineDeviceHeartbeat(businessId, overrides = {}) {
+    if (!getAuthToken())
+        return;
+    const connectivity = getConnectivityState();
+    if (!connectivity.isOnline || connectivity.isCloudReachable === "unreachable")
+        return;
+    try {
+        const deviceId = await getAppInstanceIdAsync();
+        const metadata = await getDeviceMetadata();
+        await getHttpClient().patch(`/businesses/${businessId}/devices/${encodeURIComponent(deviceId)}/heartbeat`, {
+            device_name: overrides.deviceName ?? metadata.deviceName ?? undefined,
+            platform: overrides.platform ?? metadata.platform ?? undefined,
+            os_version: overrides.osVersion ?? metadata.osVersion ?? undefined,
+            app_version: overrides.appVersion ?? metadata.appVersion ?? undefined,
+        });
+    }
+    catch (error) {
+        syncLogger.debug("OfflineAuth", "Device heartbeat failed", { error: String(error) });
+    }
+}
 export async function getStoredOfflineLicensePayload(businessId) {
     const token = await getStoredLicense(businessId);
     return token ? decodeLicensePayload(token) : null;

package/dist/offline/store.d.ts

@@ -52,6 +52,8 @@ export interface OfflineMemberCredential {
     pin_hash: string;
     enrolled_at: string;
     last_login_at?: string | null;
+    failed_attempts?: number;
+    locked_until?: string | null;
 }
 export declare function listOfflineMembers(businessId?: string): Promise<OfflineMemberCredential[]>;
 export declare function getOfflineMember(userId: string, businessId?: string): Promise<OfflineMemberCredential | null>;
@@ -68,4 +70,14 @@ export declare function createOfflineMemberCredential(args: {
     capabilities: string[];
     pin: string;
 }): Promise<OfflineMemberCredential>;
+export declare const OFFLINE_PIN_MAX_ATTEMPTS = 5;
+export interface OfflinePinLockState {
+    failedAttempts: number;
+    lockedUntil: string | null;
+    locked: boolean;
+    remainingAttempts: number;
+}
+export declare function getOfflinePinLockState(userId: string, businessId?: string): Promise<OfflinePinLockState>;
 export declare function verifyOfflineMemberPin(userId: string, pin: string, businessId?: string): Promise<boolean>;
+/** Apply an offline role change to the local credential immediately. */
+export declare function updateOfflineMemberRole(userId: string, businessId: string, role: string, capabilities?: string[]): Promise<void>;

package/dist/offline/store.js

@@ -201,18 +201,68 @@ export async function createOfflineMemberCredential(args) {
     await saveOfflineMember(member);
     return member;
 }
+export const OFFLINE_PIN_MAX_ATTEMPTS = 5;
+export async function getOfflinePinLockState(userId, businessId) {
+    const member = await getOfflineMember(userId, businessId);
+    const failedAttempts = member?.failed_attempts ?? 0;
+    const lockedUntil = member?.locked_until ?? null;
+    const locked = Boolean(lockedUntil && new Date(lockedUntil).getTime() > Date.now());
+    return {
+        failedAttempts,
+        lockedUntil,
+        locked,
+        remainingAttempts: Math.max(OFFLINE_PIN_MAX_ATTEMPTS - failedAttempts, 0),
+    };
+}
 export async function verifyOfflineMemberPin(userId, pin, businessId) {
     const member = await getOfflineMember(userId, businessId);
     if (!member)
         return false;
-    if (!/^\d{6}$/.test(pin))
+    if (member.locked_until && new Date(member.locked_until).getTime() > Date.now()) {
+        return false;
+    }
+    if (!/^\d{6}$/.test(pin)) {
+        await recordFailedPinAttempt(member);
         return false;
+    }
     const candidate = await hashPin(pin, member.pin_salt);
-    if (candidate.length !== member.pin_hash.length)
+    if (candidate.length !== member.pin_hash.length) {
+        await recordFailedPinAttempt(member);
         return false;
+    }
     let diff = 0;
     for (let i = 0; i < candidate.length; i++) {
         diff |= candidate.charCodeAt(i) ^ member.pin_hash.charCodeAt(i);
     }
-    return diff === 0;
+    if (diff === 0) {
+        if ((member.failed_attempts ?? 0) > 0 || member.locked_until) {
+            await saveOfflineMember({ ...member, failed_attempts: 0, locked_until: null });
+        }
+        return true;
+    }
+    await recordFailedPinAttempt(member);
+    return false;
+}
+async function recordFailedPinAttempt(member) {
+    const attempts = (member.failed_attempts ?? 0) + 1;
+    const now = Date.now();
+    const lockMs = attempts >= OFFLINE_PIN_MAX_ATTEMPTS
+        ? Math.min(15 * 60000, 60000 * 2 ** (attempts - OFFLINE_PIN_MAX_ATTEMPTS))
+        : 0;
+    await saveOfflineMember({
+        ...member,
+        failed_attempts: attempts,
+        locked_until: lockMs > 0 ? new Date(now + lockMs).toISOString() : null,
+    });
+}
+/** Apply an offline role change to the local credential immediately. */
+export async function updateOfflineMemberRole(userId, businessId, role, capabilities) {
+    const member = await getOfflineMember(userId, businessId);
+    if (!member)
+        return;
+    await saveOfflineMember({
+        ...member,
+        role,
+        ...(capabilities ? { capabilities } : {}),
+    });
 }

package/dist/reference/service.js

@@ -469,16 +469,29 @@ class ReferenceSyncService {
             // have the bytes in its durable image cache. Fetch only missing keys.
             const peerConnectivity = getConnectivityState();
             if (!peerConnectivity.isOnline || peerConnectivity.isCloudReachable === "unreachable") {
+                const missing = [];
                 for (const url of urls) {
                     if (!url || !url.startsWith("http"))
                         continue;
                     if (await hasCachedImage(url))
                         continue;
-                    const asset = await requestAssetFromPeer(businessId, url);
-                    if (asset?.base64) {
-                        await cacheImageFromBase64(url, asset.base64);
-                    }
+                    missing.push(url);
                 }
+                // A menu can reference dozens of images. Keep peer transfers bounded so
+                // a dark-LAN catch-up does not serialize 15s timeouts.
+                const queue = [...missing];
+                const worker = async () => {
+                    for (;;) {
+                        const url = queue.shift();
+                        if (!url)
+                            return;
+                        const asset = await requestAssetFromPeer(businessId, url);
+                        if (asset?.base64) {
+                            await cacheImageFromBase64(url, asset.base64);
+                        }
+                    }
+                };
+                await Promise.all(Array.from({ length: Math.min(3, queue.length) }, worker));
             }
             await pruneImageCache(urls);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teincfood/core",
-  "version": "0.10.4",
+  "version": "0.10.6",
   "description": "TeincFood shared offline-first core — types, sync engine, local DB, reference data, and repositories for mobile + desktop",
   "type": "module",
   "main": "dist/index.js",