@hotmeshio/long-tail 0.22.1 → 0.22.2

package/build/shared/scan-code/parse.js

@@ -0,0 +1,133 @@
+"use strict";
+// Scan-code parsing. Pure and isomorphic: the server parses every scan with
+// it, and the dashboard parses locally to route a scan into an open form.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseScanCode = parseScanCode;
+exports.fixedCodeLengths = fixedCodeLengths;
+const gtin_1 = require("./gtin");
+const GTIN_CATEGORY = '0';
+/**
+ * Parse a raw scan string against the configured schemes.
+ *
+ * The leading TWO digits pick the scheme (10-99, so a code never starts with a
+ * leading zero); the scheme then defines how the remainder splits into a
+ * single-digit category (0-9) and the target:
+ * - delimited: `10:1:ABC-123` (delimiter from the scheme row)
+ * - fixed:     `1017554332` (one category digit, then target_length digits)
+ *
+ * A digits-only code that no fixed scheme reads is a manufacturer barcode
+ * when a gtin scheme is configured and its check digit holds: the target is
+ * the 14-digit GTIN and the category is '0'. Config validation keeps fixed
+ * and gtin lengths apart, so the order here never decides a real code.
+ */
+function parseScanCode(raw, schemes) {
+    const code = raw.trim();
+    if (!code) {
+        return { ok: false, failure: { reason: 'empty', detail: 'empty scan code' } };
+    }
+    if (/^[0-9]+$/.test(code)) {
+        const fixed = schemes.find((s) => s.encoding === 'fixed' && s.version === Number(code.slice(0, 2)));
+        const fixedFits = fixed?.enabled && fitsFixed(code, fixed);
+        if (!fixedFits) {
+            const gtin = parseGtin(code, schemes);
+            if (gtin)
+                return gtin;
+        }
+    }
+    const versionToken = code.slice(0, 2);
+    const version = Number(versionToken);
+    if (!/^[0-9]{2}$/.test(versionToken) || version < 10 || version > 99) {
+        return {
+            ok: false,
+            failure: { reason: 'unknown_version', detail: `code must start with a two-digit scheme 10-99, got "${versionToken}"` },
+        };
+    }
+    const scheme = schemes.find((s) => s.version === version);
+    if (!scheme) {
+        return {
+            ok: false,
+            failure: { reason: 'unknown_version', detail: `no scan scheme configured for version ${version}` },
+        };
+    }
+    if (!scheme.enabled) {
+        return {
+            ok: false,
+            failure: { reason: 'scheme_disabled', detail: `scan scheme ${version} ("${scheme.name}") is disabled` },
+        };
+    }
+    if (scheme.encoding === 'gtin') {
+        return malformed(scheme, 'reads manufacturer barcodes, which carry no scheme prefix');
+    }
+    if (scheme.encoding === 'delimited') {
+        return parseDelimited(code, version, scheme);
+    }
+    return parseFixed(code, version, scheme);
+}
+function fitsFixed(code, scheme) {
+    const expected = 3 + (scheme.target_length ?? 0);
+    return code.length === expected || code.length === expected + 1;
+}
+/** A manufacturer barcode, or null when the code is not one any gtin scheme reads. */
+function parseGtin(code, schemes) {
+    if (!(0, gtin_1.isValidGtin)(code))
+        return null;
+    const gtin = schemes.find((s) => s.encoding === 'gtin' && s.enabled)
+        ?? schemes.find((s) => s.encoding === 'gtin');
+    if (!gtin)
+        return null;
+    if (!gtin.enabled) {
+        return {
+            ok: false,
+            failure: { reason: 'scheme_disabled', detail: `scan scheme ${gtin.version} ("${gtin.name}") is disabled` },
+        };
+    }
+    return {
+        ok: true,
+        parsed: { version: gtin.version, category: GTIN_CATEGORY, target: (0, gtin_1.normalizeGtin)(code), raw: code },
+        scheme: gtin,
+    };
+}
+function parseDelimited(code, version, scheme) {
+    const d = scheme.delimiter;
+    // version(2 digits) <d> category(1 digit) <d> target(rest, non-empty)
+    if (code[2] !== d) {
+        return malformed(scheme, `expected "${d}" after the two-digit scheme`);
+    }
+    const category = code.slice(3, 4);
+    if (!/^[0-9]$/.test(category)) {
+        return malformed(scheme, 'category must be a single digit');
+    }
+    if (code[4] !== d) {
+        return malformed(scheme, `expected "${d}" after the category`);
+    }
+    const target = code.slice(5);
+    if (!target) {
+        return malformed(scheme, 'target is empty');
+    }
+    return { ok: true, parsed: { version, category, target }, scheme };
+}
+function parseFixed(code, version, scheme) {
+    const targetLength = scheme.target_length ?? 0;
+    const expected = 2 + 1 + targetLength;
+    // UPC-A wedges deliver the trailing check digit too; accept it as slack.
+    if (!/^[0-9]+$/.test(code)) {
+        return malformed(scheme, 'fixed encoding accepts digits only');
+    }
+    if (code.length !== expected && code.length !== expected + 1) {
+        return malformed(scheme, `expected ${expected} digits (or ${expected + 1} with check digit), got ${code.length}`);
+    }
+    const category = code.slice(2, 3);
+    const target = code.slice(3, 3 + targetLength);
+    return { ok: true, parsed: { version, category, target }, scheme };
+}
+function malformed(scheme, detail) {
+    return {
+        ok: false,
+        failure: { reason: 'malformed', detail: `scheme ${scheme.version} ("${scheme.name}"): ${detail}` },
+    };
+}
+/** The total code lengths a fixed scheme accepts (with and without the check-digit slack). */
+function fixedCodeLengths(scheme) {
+    const expected = 3 + (scheme.target_length ?? 0);
+    return [expected, expected + 1];
+}

package/build/system/mcp-servers/admin/scan-codes.js

@@ -50,16 +50,21 @@ function registerScanCodeTools(server) {
     // mirrors POST /api/scan-codes/execute
     server.registerTool('execute_scan_code', {
         title: 'Execute Scan Code',
-        description: 'Execute a raw scan code (version:category:target). Parses against the ' +
-            'configured schemes, walks the rule\'s condition/action steps, and returns ' +
-            'a structured outcome (executed, confirm_required, matched_list, ' +
-            'no_match_fallback, unconfigured, invalid_code, forbidden, conflict).',
+        description: 'Execute a raw scan code (version:category:target, or a manufacturer barcode ' +
+            'under a gtin scheme). Parses against the configured schemes, walks the ' +
+            'rule\'s condition/action steps, and returns a structured outcome: executed, ' +
+            'matched_list, confirm_required, choices, held (a subject to pass back as ' +
+            '`subject` on the next scan), refused (nothing written; refusal names why), ' +
+            'subject_stale, no_open_container, no_match_fallback, not_primed, ' +
+            'identity_primed, identity_unknown, unconfigured, invalid_code, forbidden, conflict.',
         inputSchema: schemas_1.executeScanCodeSchema,
     }, async (args) => {
         const result = await scanCodesApi.executeScanCode({
             code: args.code,
             actingToken: args.actingToken,
             previousActingToken: args.previousActingToken,
+            subject: args.subject,
+            stationRole: args.stationRole,
         }, await systemAuth());
         return asText(result.data ?? { error: result.error });
     });
@@ -108,6 +113,7 @@ function registerScanCodeTools(server) {
             name: args.name,
             steps: args.steps,
             fallback: args.fallback,
+            notPrimed: args.notPrimed,
             enabled: args.enabled,
         });
         return asText(result.data ?? { error: result.error });