@teincfood/core 0.7.9 → 0.8.0

package/dist/local-node/adapters.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Local Node adapters — platform drivers implement these.
+ */
+import type { Command, DomainEvent } from "../sync/types";
+import type { ReferenceDataKey, ReferenceDataRecord } from "../reference/types";
+import type { DiscoveredNode } from "./store";
+export interface DiscoveryAdapter {
+    setOptions(opts: {
+        deviceId: string;
+        deviceName?: string;
+        onNodeFound: (node: DiscoveredNode) => void;
+        onNodeLost: (deviceId: string) => void;
+    }): void;
+    startScanning(): void;
+    stopScanning(): void;
+    startPublishing(opts: {
+        deviceId: string;
+        deviceName?: string;
+        port: number;
+        onNodeFound: (node: DiscoveredNode) => void;
+        onNodeLost: (deviceId: string) => void;
+    }): void;
+    stop(): void;
+}
+export interface LocalNodeServer {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    isListening(): boolean;
+    broadcast(event: DomainEvent): void;
+}
+export interface LocalNodeClient {
+    connect(): Promise<void>;
+    disconnect(): void;
+    isConnected(): boolean;
+    execute(command: Command): Promise<DomainEvent[]>;
+    requestReferenceData(businessId: string, keys: ReferenceDataKey[]): Promise<{
+        data: Partial<Record<ReferenceDataKey, ReferenceDataRecord | null>>;
+    }>;
+    publishEvent?(event: DomainEvent): Promise<void> | void;
+}
+export interface TransportAdapter {
+    createServer(opts: {
+        port: number;
+        businessId: string;
+        secret: string;
+        onCommand: (command: Command) => Promise<DomainEvent[]>;
+        onRelayEvent: (event: DomainEvent) => void;
+        onClientConnected: (info: {
+            deviceId: string;
+            deviceName?: string;
+            host?: string;
+        }) => void;
+        onClientDisconnected: (deviceId: string) => void;
+    }): LocalNodeServer;
+    createClient(opts: {
+        node: {
+            deviceId: string;
+            host: string;
+            port: number;
+        };
+        businessId: string;
+        secret: string;
+        onEvent: (event: DomainEvent) => void;
+        onConnected: () => void;
+        onDisconnected: () => void;
+        onError: (error: unknown) => void;
+    }): LocalNodeClient;
+}
+export interface KeepAliveAdapter {
+    activate(tag: string): Promise<void>;
+    deactivate(tag: string): Promise<void>;
+}
+export interface LocalNodeDeps {
+    getDeviceId: () => string | Promise<string>;
+    getDeviceName?: () => string | undefined;
+    getBusiness: () => {
+        id: string;
+    } | null;
+    getAuth: () => {
+        user: unknown | null;
+        accessToken: string | null;
+    };
+    discovery: DiscoveryAdapter;
+    transport: TransportAdapter;
+    keepAlive?: KeepAliveAdapter;
+    cloudCommandTimeoutMs?: number;
+}

package/dist/local-node/adapters.js

@@ -0,0 +1,4 @@
+/**
+ * Local Node adapters — platform drivers implement these.
+ */
+export {};

package/dist/local-node/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./types";
+export * from "./security";
+export * from "./store";
+export * from "./adapters";
+export * from "./service";

package/dist/local-node/index.js

@@ -0,0 +1,5 @@
+export * from "./types";
+export * from "./security";
+export * from "./store";
+export * from "./adapters";
+export * from "./service";

package/dist/local-node/security.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Local Node security helpers — platform-agnostic.
+ *
+ * SINGLE OWNER of mesh crypto (formula + inputs). Apps (Business/Desktop/Rust)
+ * MUST NOT derive or re-implement this: core derives the secret once per
+ * business and hands the opaque value to transports. Transports only carry it.
+ *
+ * Mesh decision: the secret is business-only — `SHA256("teinc-lan:{id}:")`
+ * with a permanently empty owner segment. Same business_id ⇒ same secret on
+ * every device, regardless of which owner fields each app's store happens to
+ * carry (that variance caused `invalid_proof` between devices). The trailing
+ * colon is kept so the wire value is byte-identical to the historic formula.
+ *
+ * Pure JS WebCrypto/Node fallback so core does not depend on expo-crypto.
+ */
+/**
+ * Self-contained SHA-256 (FIPS 180-4), no platform dependency. Slower than
+ * native but handshake-rate only. Pinned by vectors in security.test.ts.
+ */
+export declare function sha256Pure(data: Uint8Array): Uint8Array;
+export declare function deriveLanSecret(business: {
+    id: string;
+}): Promise<string>;
+export declare function generateNonce(): Promise<string>;
+export declare function computeProof(secret: string, nonce: string): Promise<string>;

package/dist/local-node/security.js

@@ -0,0 +1,149 @@
+/**
+ * Local Node security helpers — platform-agnostic.
+ *
+ * SINGLE OWNER of mesh crypto (formula + inputs). Apps (Business/Desktop/Rust)
+ * MUST NOT derive or re-implement this: core derives the secret once per
+ * business and hands the opaque value to transports. Transports only carry it.
+ *
+ * Mesh decision: the secret is business-only — `SHA256("teinc-lan:{id}:")`
+ * with a permanently empty owner segment. Same business_id ⇒ same secret on
+ * every device, regardless of which owner fields each app's store happens to
+ * carry (that variance caused `invalid_proof` between devices). The trailing
+ * colon is kept so the wire value is byte-identical to the historic formula.
+ *
+ * Pure JS WebCrypto/Node fallback so core does not depend on expo-crypto.
+ */
+const LAN_SECRET_SALT = "teinc-lan";
+function bytesToHex(bytes) {
+    return Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+}
+function hexToBytes(hex) {
+    const out = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < out.length; i++)
+        out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    return out;
+}
+async function sha256Hex(input) {
+    const data = new TextEncoder().encode(input);
+    // 1) WebCrypto (RN Hermes may expose global crypto.subtle, Tauri does)
+    try {
+        const g = globalThis;
+        const subtle = g?.crypto?.subtle;
+        if (subtle) {
+            const buf = await subtle.digest("SHA-256", data);
+            return bytesToHex(new Uint8Array(buf));
+        }
+    }
+    catch { }
+    // 2) Node crypto (tests / desktop node)
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const nodeCrypto = require("crypto");
+        if (nodeCrypto?.createHash)
+            return nodeCrypto.createHash("sha256").update(data).digest("hex");
+    }
+    catch { }
+    // 3) Pure-JS SHA-256 (Hermes/RN has neither subtle nor node crypto).
+    // MUST be real SHA-256 — proofs must verify cross-platform, and the old
+    // DJB placeholder produced zero-padded non-hashes that silently failed
+    // every handshake. No app action needed: identical output everywhere.
+    return bytesToHex(sha256Pure(data));
+}
+/**
+ * Self-contained SHA-256 (FIPS 180-4), no platform dependency. Slower than
+ * native but handshake-rate only. Pinned by vectors in security.test.ts.
+ */
+export function sha256Pure(data) {
+    const K = [
+        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+        0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+    ];
+    let h0 = 0x6a09e667, h1 = 0xbb67ae85, h2 = 0x3c6ef372, h3 = 0xa54ff53a;
+    let h4 = 0x510e527f, h5 = 0x9b05688c, h6 = 0x1f83d9ab, h7 = 0x5be0cd19;
+    const bitLen = data.length * 8;
+    const paddedLen = (((data.length + 8) >> 6) + 1) << 6;
+    const msg = new Uint8Array(paddedLen);
+    msg.set(data);
+    msg[data.length] = 0x80;
+    const dv = new DataView(msg.buffer);
+    dv.setUint32(paddedLen - 4, bitLen >>> 0, false);
+    dv.setUint32(paddedLen - 8, Math.floor(bitLen / 0x100000000), false);
+    const w = new Int32Array(64);
+    const rotr = (x, n) => (x >>> n) | (x << (32 - n));
+    for (let off = 0; off < paddedLen; off += 64) {
+        for (let i = 0; i < 16; i++)
+            w[i] = dv.getInt32(off + i * 4, false);
+        for (let i = 16; i < 64; i++) {
+            const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >>> 3);
+            const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >>> 10);
+            w[i] = (w[i - 16] + s0 + w[i - 7] + s1) | 0;
+        }
+        let [a, b, c, d, e, f, g, h] = [h0, h1, h2, h3, h4, h5, h6, h7];
+        for (let i = 0; i < 64; i++) {
+            const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+            const ch = (e & f) ^ (~e & g);
+            const t1 = (h + S1 + ch + K[i] + w[i]) | 0;
+            const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const t2 = (S0 + maj) | 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + t1) | 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) | 0;
+        }
+        h0 = (h0 + a) | 0;
+        h1 = (h1 + b) | 0;
+        h2 = (h2 + c) | 0;
+        h3 = (h3 + d) | 0;
+        h4 = (h4 + e) | 0;
+        h5 = (h5 + f) | 0;
+        h6 = (h6 + g) | 0;
+        h7 = (h7 + h) | 0;
+    }
+    const out = new Uint8Array(32);
+    const odv = new DataView(out.buffer);
+    [h0, h1, h2, h3, h4, h5, h6, h7].forEach((v, i) => odv.setInt32(i * 4, v, false));
+    return out;
+}
+export async function deriveLanSecret(business) {
+    return sha256Hex(`${LAN_SECRET_SALT}:${business.id}:`);
+}
+export async function generateNonce() {
+    try {
+        const g = globalThis;
+        const cryptoObj = g?.crypto;
+        if (cryptoObj?.getRandomValues) {
+            const b = new Uint8Array(16);
+            cryptoObj.getRandomValues(b);
+            return bytesToHex(b);
+        }
+    }
+    catch { }
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const nodeCrypto = require("crypto");
+        if (nodeCrypto?.randomBytes)
+            return bytesToHex(nodeCrypto.randomBytes(16));
+    }
+    catch { }
+    // fallback Math.random
+    const b = new Uint8Array(16);
+    for (let i = 0; i < 16; i++)
+        b[i] = Math.floor(Math.random() * 256);
+    return bytesToHex(b);
+}
+export async function computeProof(secret, nonce) {
+    return sha256Hex(`${nonce}:${secret}`);
+}

package/dist/local-node/service.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Local Node Service — mesh, no elected, every isLocalNodeEnabled device is both server and client.
+ */
+import type { Command, DomainEvent } from "../sync/types";
+import type { LocalNodeInfo } from "./types";
+import type { LocalNodeDeps, LocalNodeClient } from "./adapters";
+import type { ReferenceDataKey } from "../reference/types";
+declare class LocalNodeServiceCore {
+    private server;
+    private peers;
+    private peerInfos;
+    private mode;
+    private businessId;
+    private secret;
+    private subscribed;
+    private cachedDeviceId;
+    private lifecyclePromise;
+    private starting;
+    private deps;
+    /** mDNS publish state — a failed publish must never abort discovery. */
+    private published;
+    /** Whether discovery scanning was successfully started. */
+    private discovering;
+    init(deps: LocalNodeDeps): void;
+    private getDeps;
+    private getDeviceId;
+    private runLifecycle;
+    private runInitialize;
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    reconnectNow(): void;
+    private runShutdown;
+    isLocalNode(): boolean;
+    isConnectedToNode(): boolean;
+    /** Mesh legibility for Diagnostics screens: publish/scan state per leg. */
+    getMeshStatus(): {
+        mode: string;
+        listening: boolean;
+        published: boolean;
+        discovering: boolean;
+        peers: number;
+    };
+    getClient(): LocalNodeClient | null;
+    getElectedNode(): LocalNodeInfo | null;
+    broadcastToClients(event: DomainEvent): void;
+    private storeUnsub;
+    private setupStoreSubscriptions;
+    private teardownStoreSubscriptions;
+    private startAsNode;
+    /**
+     * (Re)publish this node's mDNS advertisement. Isolated from server bring-up
+     * and discovery: a publish throw must never abort scanning, sweeping, or
+     * peer dials. Safe to call repeatedly (drivers dedupe internally).
+     */
+    private ensurePublished;
+    private startDiscovery;
+    /** Start scanning if not already running (idempotent drivers ignore repeats). */
+    private ensureDiscovery;
+    private dialInFlight;
+    private dialTimers;
+    private sweepTimer;
+    /** deviceId -> timestamp of last business_mismatch rejection. Foreign-business
+     * peers (test rigs, neighboring shops) would otherwise be redialed on every
+     * discovery event; back off quietly and re-probe after the window. */
+    private mismatchBackoff;
+    private static readonly MISMATCH_BACKOFF_MS;
+    private startPeerSweep;
+    private stopPeerSweep;
+    private connectToPeer;
+    private settleDial;
+    handleNodeCommand(command: Command): Promise<DomainEvent | null>;
+    requestReferenceData(businessId: string, keys: ReferenceDataKey[]): Promise<Partial<Record<ReferenceDataKey, import("../reference/types").ReferenceDataRecord | null>> | null>;
+    getState(): {
+        isLocalNode: boolean;
+        isConnectedToNode: boolean;
+        electedNode: LocalNodeInfo | null;
+        client: LocalNodeClient | null;
+    };
+}
+export declare const localNodeService: LocalNodeServiceCore;
+export declare function initLocalNodeService(deps: LocalNodeDeps): LocalNodeServiceCore;
+export type LocalNodeService = LocalNodeServiceCore;
+export {};