@hotmeshio/long-tail 0.30.4 → 0.31.0

package/build/start/adapters.js

@@ -21,6 +21,10 @@ const features_1 = require("../modules/features");
 const search_1 = require("../modules/search");
 const branding_1 = require("../modules/branding");
 const display_1 = require("../modules/display");
+const transports_1 = require("../lib/labels/transports");
+const media_1 = require("../services/labels/media");
+const render_pdf_1 = require("../services/labels/render-pdf");
+const redact_1 = require("../services/user/redact");
 const socket_auth_1 = require("./socket-auth");
 /**
  * Register all adapters (logging, telemetry, events, maintenance,
@@ -32,6 +36,18 @@ function registerAdapters(startConfig) {
     (0, search_1.configureSearch)(startConfig.search);
     (0, branding_1.configureBranding)(startConfig.branding);
     (0, display_1.configureDisplay)(startConfig.display);
+    // Label sheets: host media first, so the default may name one.
+    if (startConfig.labels?.media)
+        (0, media_1.registerLabelMedia)(startConfig.labels.media);
+    if (startConfig.labels?.defaultMedia)
+        (0, media_1.setDefaultLabelMedia)(startConfig.labels.defaultMedia);
+    if (startConfig.labels?.font)
+        (0, render_pdf_1.registerLabelFonts)(startConfig.labels.font);
+    if (startConfig.labels?.protectIdentityKeys !== undefined)
+        (0, redact_1.setIdentityKeyProtection)(startConfig.labels.protectIdentityKeys);
+    for (const [name, transport] of Object.entries(startConfig.labels?.transports ?? {})) {
+        transports_1.labelTransportRegistry.register(name, transport);
+    }
     // Logging (register first so subsequent log calls use it)
     if (startConfig.logging?.adapter) {
         logger_1.loggerRegistry.register(startConfig.logging.adapter);

package/build/start/workers.js

@@ -102,8 +102,11 @@ async function collectWorkers(startConfig) {
     ];
     logger_1.loggerRegistry.info('[long-tail] system workflows loaded');
     if (startConfig.examples) {
-        const { exampleWorkers } = await Promise.resolve().then(() => __importStar(require('../examples')));
+        const { exampleWorkers, storageDropTransport, STORAGE_DROP_TRANSPORT } = await Promise.resolve().then(() => __importStar(require('../examples')));
         workers.push(...exampleWorkers);
+        const { labelTransportRegistry } = await Promise.resolve().then(() => __importStar(require('../lib/labels/transports')));
+        if (!labelTransportRegistry.has(STORAGE_DROP_TRANSPORT))
+            labelTransportRegistry.register(STORAGE_DROP_TRANSPORT, storageDropTransport);
         logger_1.loggerRegistry.info('[long-tail] example workflows loaded');
     }
     return { workers, builtinMcpServerFactories };
@@ -499,10 +502,11 @@ async function startWorkers(startConfig, workers, builtinMcpServerFactories) {
     // applies first — rule validation reads its kind.
     if (startConfig.scanSchemes?.length) {
         const { seedScanScheme, seedScanRule, applyScanScheme, applyScanRule, listScanSchemes, listScanRules, } = await Promise.resolve().then(() => __importStar(require('../services/scan-code')));
+        const { applyLabelTemplate, seedLabelTemplate, listLabelTemplates } = await Promise.resolve().then(() => __importStar(require('../services/labels/templates')));
         const scanReport = (0, apply_report_1.newSurfaceReport)();
         for (const scheme of startConfig.scanSchemes) {
             const codeOwned = (0, apply_report_1.ownedByCode)(scheme.reset, configSource);
-            const { rules, reset: _reset, ...schemeInput } = scheme;
+            const { rules, labels, reset: _reset, ...schemeInput } = scheme;
             try {
                 if (codeOwned) {
                     let outcome = await applyScanScheme(schemeInput);
@@ -511,6 +515,11 @@ async function startWorkers(startConfig, workers, builtinMcpServerFactories) {
                         if (ruleOutcome === 'applied')
                             outcome = 'applied';
                     }
+                    for (const label of labels ?? []) {
+                        const labelOutcome = await applyLabelTemplate({ scheme_version: scheme.version, ...label });
+                        if (labelOutcome === 'applied')
+                            outcome = 'applied';
+                    }
                     (0, apply_report_1.recordOutcome)(scanReport, `scheme ${scheme.version}`, outcome);
                     if (outcome === 'applied')
                         logger_1.loggerRegistry.info(`[long-tail] scan scheme applied: ${scheme.version}`);
@@ -519,12 +528,19 @@ async function startWorkers(startConfig, workers, builtinMcpServerFactories) {
                     scanReport.orphans.push(...existingRules
                         .filter((r) => !declaredCategories.has(r.category))
                         .map((r) => `${scheme.version}/${r.category}`));
+                    const declaredLabels = new Set((labels ?? []).map((l) => l.name));
+                    scanReport.orphans.push(...(await listLabelTemplates(scheme.version))
+                        .filter((t) => !declaredLabels.has(t.name))
+                        .map((t) => `${scheme.version}/label:${t.name}`));
                 }
                 else {
                     const inserted = await seedScanScheme(schemeInput);
                     for (const rule of rules ?? []) {
                         await seedScanRule({ scheme_version: scheme.version, ...rule });
                     }
+                    for (const label of labels ?? []) {
+                        await seedLabelTemplate({ scheme_version: scheme.version, ...label });
+                    }
                     (0, apply_report_1.recordOutcome)(scanReport, `scheme ${scheme.version}`, 'db-owned');
                     if (inserted)
                         logger_1.loggerRegistry.info(`[long-tail] scan scheme seeded: ${scheme.version}`);

package/build/system/mcp-servers/admin/index.js

@@ -60,6 +60,7 @@ const exports_1 = require("./exports");
 const overview_1 = require("./overview");
 const diagnostics_1 = require("./diagnostics");
 const scan_codes_1 = require("./scan-codes");
+const labels_1 = require("./labels");
 const domain_context_1 = require("./domain-context");
 const announcements_1 = require("./announcements");
 let server = null;
@@ -91,6 +92,7 @@ async function createAdminServer(options) {
     (0, overview_1.registerOverviewTools)(instance);
     (0, diagnostics_1.registerDiagnosticsTools)(instance);
     (0, scan_codes_1.registerScanCodeTools)(instance);
+    (0, labels_1.registerLabelTools)(instance);
     (0, domain_context_1.registerDomainContextTools)(instance);
     (0, announcements_1.registerAnnouncementTools)(instance);
     logger_1.loggerRegistry.info(`[lt-mcp:admin] ${name} ready (${(0, registered_tools_1.registeredToolCount)(instance)} tools registered)`);

package/build/system/mcp-servers/admin/labels-schemas.d.ts

@@ -0,0 +1,192 @@
+import { z } from 'zod';
+export declare const listLabelTemplatesSchema: z.ZodObject<{
+    scheme: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    scheme?: number | undefined;
+}, {
+    scheme?: number | undefined;
+}>;
+export declare const upsertLabelTemplateSchema: z.ZodObject<{
+    name: z.ZodString;
+    scheme_version: z.ZodNumber;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    codes: z.ZodArray<z.ZodObject<{
+        category: z.ZodString;
+        caption: z.ZodOptional<z.ZodString>;
+        tone: z.ZodEnum<["solid", "outline", "plain"]>;
+    }, "strip", z.ZodTypeAny, {
+        category: string;
+        tone: "solid" | "outline" | "plain";
+        caption?: string | undefined;
+    }, {
+        category: string;
+        tone: "solid" | "outline" | "plain";
+        caption?: string | undefined;
+    }>, "many">;
+    text: z.ZodOptional<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        lines: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        title?: string | undefined;
+        lines?: string[] | undefined;
+    }, {
+        title?: string | undefined;
+        lines?: string[] | undefined;
+    }>>;
+    symbology: z.ZodOptional<z.ZodEnum<["code128", "qrcode", "datamatrix"]>>;
+    human_readable: z.ZodOptional<z.ZodBoolean>;
+    media: z.ZodOptional<z.ZodString>;
+    sensitive: z.ZodOptional<z.ZodBoolean>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    expected_revision: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    scheme_version: number;
+    title: string;
+    codes: {
+        category: string;
+        tone: "solid" | "outline" | "plain";
+        caption?: string | undefined;
+    }[];
+    enabled?: boolean | undefined;
+    text?: {
+        title?: string | undefined;
+        lines?: string[] | undefined;
+    } | undefined;
+    description?: string | undefined;
+    symbology?: "code128" | "qrcode" | "datamatrix" | undefined;
+    human_readable?: boolean | undefined;
+    media?: string | undefined;
+    sensitive?: boolean | undefined;
+    expected_revision?: number | undefined;
+}, {
+    name: string;
+    scheme_version: number;
+    title: string;
+    codes: {
+        category: string;
+        tone: "solid" | "outline" | "plain";
+        caption?: string | undefined;
+    }[];
+    enabled?: boolean | undefined;
+    text?: {
+        title?: string | undefined;
+        lines?: string[] | undefined;
+    } | undefined;
+    description?: string | undefined;
+    symbology?: "code128" | "qrcode" | "datamatrix" | undefined;
+    human_readable?: boolean | undefined;
+    media?: string | undefined;
+    sensitive?: boolean | undefined;
+    expected_revision?: number | undefined;
+}>;
+export declare const deleteLabelTemplateSchema: z.ZodObject<{
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+}, {
+    name: string;
+}>;
+export declare const renderLabelSheetSchema: z.ZodObject<{
+    template: z.ZodString;
+    source: z.ZodUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"list">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "list";
+        text: string;
+    }, {
+        kind: "list";
+        text: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"range">;
+        prefix: z.ZodOptional<z.ZodString>;
+        from: z.ZodNumber;
+        to: z.ZodNumber;
+        pad: z.ZodOptional<z.ZodNumber>;
+        suffix: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "range";
+        from: number;
+        to: number;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        pad?: number | undefined;
+    }, {
+        kind: "range";
+        from: number;
+        to: number;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        pad?: number | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"escalations">;
+        ids: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "escalations";
+        ids: string[];
+    }, {
+        kind: "escalations";
+        ids: string[];
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"facets">;
+        query: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "facets";
+        query: Record<string, any>;
+    }, {
+        kind: "facets";
+        query: Record<string, any>;
+    }>]>;
+    media: z.ZodOptional<z.ZodString>;
+    startPosition: z.ZodOptional<z.ZodNumber>;
+    copies: z.ZodOptional<z.ZodNumber>;
+    format: z.ZodEnum<["pdf", "zpl"]>;
+}, "strip", z.ZodTypeAny, {
+    source: {
+        kind: "list";
+        text: string;
+    } | {
+        kind: "range";
+        from: number;
+        to: number;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        pad?: number | undefined;
+    } | {
+        kind: "escalations";
+        ids: string[];
+    } | {
+        kind: "facets";
+        query: Record<string, any>;
+    };
+    format: "pdf" | "zpl";
+    template: string;
+    media?: string | undefined;
+    startPosition?: number | undefined;
+    copies?: number | undefined;
+}, {
+    source: {
+        kind: "list";
+        text: string;
+    } | {
+        kind: "range";
+        from: number;
+        to: number;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        pad?: number | undefined;
+    } | {
+        kind: "escalations";
+        ids: string[];
+    } | {
+        kind: "facets";
+        query: Record<string, any>;
+    };
+    format: "pdf" | "zpl";
+    template: string;
+    media?: string | undefined;
+    startPosition?: number | undefined;
+    copies?: number | undefined;
+}>;

package/build/system/mcp-servers/admin/labels-schemas.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderLabelSheetSchema = exports.deleteLabelTemplateSchema = exports.upsertLabelTemplateSchema = exports.listLabelTemplatesSchema = void 0;
+const zod_1 = require("zod");
+const tone = zod_1.z.enum(['solid', 'outline', 'plain']);
+const symbology = zod_1.z.enum(['code128', 'qrcode', 'datamatrix']);
+exports.listLabelTemplatesSchema = zod_1.z.object({
+    scheme: zod_1.z.number().int().optional().describe('Only templates for this scan scheme version'),
+});
+exports.upsertLabelTemplateSchema = zod_1.z.object({
+    name: zod_1.z.string().describe('Template id: lowercase letters, digits and dashes'),
+    scheme_version: zod_1.z.number().int().describe('The scan scheme whose codes the label prints'),
+    title: zod_1.z.string().describe('Display name in pickers'),
+    description: zod_1.z.string().optional(),
+    codes: zod_1.z.array(zod_1.z.object({
+        category: zod_1.z.string().describe('A rule category of the scheme, 0-9'),
+        caption: zod_1.z.string().optional().describe('The act printed beside the code; defaults to the rule name'),
+        tone: tone.describe('Caption band: solid (filled), outline, or plain'),
+    })).min(1).max(4),
+    text: zod_1.z.object({
+        title: zod_1.z.string().optional().describe('Largest line, in label tokens: {target}, {item.<facet>}, {user.<key>}, {scheme.name}'),
+        lines: zod_1.z.array(zod_1.z.string()).max(2).optional(),
+    }).optional(),
+    symbology: symbology.optional(),
+    human_readable: zod_1.z.boolean().optional().describe('Print the code as text under the symbol'),
+    media: zod_1.z.string().optional().describe('Default media preset id, e.g. a4-l7160'),
+    sensitive: zod_1.z.boolean().optional().describe('Ask for confirmation and record subjects when printing'),
+    enabled: zod_1.z.boolean().optional(),
+    expected_revision: zod_1.z.number().int().optional().describe('Write only if the stored revision matches'),
+});
+exports.deleteLabelTemplateSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+});
+exports.renderLabelSheetSchema = zod_1.z.object({
+    template: zod_1.z.string().describe('Label template name'),
+    source: zod_1.z.union([
+        zod_1.z.object({ kind: zod_1.z.literal('list'), text: zod_1.z.string().describe('One target per line; a header row starting with "target" names {item.<column>} tokens') }),
+        zod_1.z.object({ kind: zod_1.z.literal('range'), prefix: zod_1.z.string().optional(), from: zod_1.z.number().int(), to: zod_1.z.number().int(), pad: zod_1.z.number().int().optional(), suffix: zod_1.z.string().optional() }),
+        zod_1.z.object({ kind: zod_1.z.literal('escalations'), ids: zod_1.z.array(zod_1.z.string()) }),
+        zod_1.z.object({ kind: zod_1.z.literal('facets'), query: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).describe('A FacetQuery: role, facets, …') }),
+    ]),
+    media: zod_1.z.string().optional().describe('Media preset id; defaults to the template media'),
+    startPosition: zod_1.z.number().int().optional(),
+    copies: zod_1.z.number().int().optional(),
+    format: zod_1.z.enum(['pdf', 'zpl']).describe('pdf for sheet stock, zpl for thermal media'),
+});

package/build/system/mcp-servers/admin/labels.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Label template and label sheet tools — mirrors routes/labels.ts
+ *
+ * render_label_sheet issues a sheet as the caller and stores it as a file
+ * with a short-lived link. It prints item labels only: identity templates
+ * (badges) are printed by people, with a confirmation, never by an agent.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerLabelTools(server: McpServer): void;

package/build/system/mcp-servers/admin/labels.js

@@ -0,0 +1,101 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerLabelTools = registerLabelTools;
+const labelsApi = __importStar(require("../../../api/labels"));
+const labels_1 = require("../../../services/labels");
+const scan_code_1 = require("../../../services/scan-code");
+const storage_1 = require("../../../lib/storage");
+const types_1 = require("../../../types");
+const caller_auth_1 = require("../caller-auth");
+const labels_schemas_1 = require("./labels-schemas");
+const SIGNED_URL_SECONDS = 600;
+function asText(payload, isError = false) {
+    return { ...(isError ? { isError: true } : {}), content: [{ type: 'text', text: JSON.stringify(payload) }] };
+}
+function registerLabelTools(server) {
+    // mirrors GET /api/labels/templates
+    server.registerTool('list_label_templates', {
+        title: 'List Label Templates',
+        description: 'List label templates: which scan scheme each prints, its codes with captions, text, symbology and default media.',
+        inputSchema: labels_schemas_1.listLabelTemplatesSchema,
+    }, async (args) => {
+        const result = await labelsApi.listLabelTemplates({ scheme: args.scheme });
+        return asText(result.data ?? { error: result.error }, !!result.error);
+    });
+    // mirrors PUT /api/labels/templates/:name
+    server.registerTool('upsert_label_template', {
+        title: 'Upsert Label Template',
+        description: 'Create or replace a label template for a scan scheme: 1-4 of the scheme\'s rules printed as codes, ' +
+            'each beside its caption in a solid, outline or plain band; a title and up to two lines in label tokens.',
+        inputSchema: labels_schemas_1.upsertLabelTemplateSchema,
+    }, async (args) => {
+        const result = await labelsApi.upsertLabelTemplate(args);
+        return asText(result.data ?? { error: result.error }, !!result.error);
+    });
+    // mirrors DELETE /api/labels/templates/:name
+    server.registerTool('delete_label_template', { title: 'Delete Label Template', description: 'Delete one label template by name.', inputSchema: labels_schemas_1.deleteLabelTemplateSchema }, async (args) => {
+        const result = await labelsApi.deleteLabelTemplate(args);
+        return asText(result.data ?? { error: result.error }, !!result.error);
+    });
+    // mirrors POST /api/labels/issue (item templates only)
+    server.registerTool('render_label_sheet', {
+        title: 'Render Label Sheet',
+        description: 'Issue a sheet of item labels as the caller and store it as a PDF (sheet stock) or ZPL (thermal) file. ' +
+            'Returns the job id, the file ref, a link valid for 10 minutes, and warnings for codes that would fail on the floor. ' +
+            'Badge (identity) templates are refused: people print badges.',
+        inputSchema: labels_schemas_1.renderLabelSheetSchema,
+    }, async (args, extra) => {
+        const template = await (0, labels_1.getLabelTemplate)(args.template);
+        const scheme = template ? await (0, scan_code_1.getScanScheme)(template.scheme_version) : null;
+        if (template && (template.sensitive || scheme?.kind === types_1.SCAN_SCHEME_KINDS.IDENTITY)) {
+            return asText({ error: `"${args.template}" prints credentials or sensitive labels; a person prints it from the dashboard` }, true);
+        }
+        const result = await labelsApi.issueLabels({
+            template: args.template,
+            source: args.source,
+            layout: { media: args.media, startPosition: args.startPosition, copies: args.copies },
+            output: args.format,
+        }, await (0, caller_auth_1.callerAuth)(extra));
+        if (result.error)
+            return asText({ error: result.error }, true);
+        const { job, warnings, pdf, zpl } = result.data;
+        const key = `labels/${job.id}.${args.format}`;
+        const storage = (0, storage_1.getStorageBackend)();
+        const { ref } = await storage.write(key, Buffer.from(args.format === 'pdf' ? pdf : zpl));
+        const url = await storage.getSignedUrl(key, SIGNED_URL_SECONDS);
+        return asText({ jobId: job.id, labelCount: job.label_count, ref, url, warnings });
+    });
+}