u

src/api/agent/index.js

@@ -399,6 +399,21 @@ async function handleState(req, res) {
             }
         }
 
+        if (rawState?.job?.id && rawState?.job?.state) {
+            try {
+                const updatedJob = await printerjobDb.updateState(
+                    { agentId: req.agent.id },
+                    rawState.job.id,
+                    rawState.job.state
+                );
+                if (req.agent?.companyId) {
+                    emit('printerjob', { companyId: req.agent.companyId, data: { job: updatedJob } });
+                }
+            } catch (jobErr) {
+                log.debug(`Agent reported job state update for ${rawState.job.id}:`, jobErr?.message);
+            }
+        }
+
         if (rawPrinters && req.agent.companyId) {
             updateAgentPrinters(req.agent.companyId, req.agent.id, req.agent.name, rawPrinters);
         } else if (anyAgentPrinterCreated && req.agent.companyId) {

src/api/routes/article/media.js

@@ -6,6 +6,11 @@ import * as db from '../../../db/article.js';
 import * as printerDb from '../../../db/printer.js';
 import * as agentprinterDb from '../../../db/agentprinter.js';
 import * as labeltemplateDb from '../../../db/labeltemplate.js';
+import * as printerjobDb from '../../../db/printerjob.js';
+import { emit } from '../../sse.js';
+import { notifyAgentJob } from '../../agent/index.js';
+import { pngToZpl } from '../../../services/zplService.js';
+import { applyZplCopies } from '../zpljob.js';
 import {
     AVIF_BODY_LIMIT,
     emitArticleSignal,
@@ -395,13 +400,16 @@ export function register(app, basePath = '') {
 
         try {
             let printer = await printerDb.getById(req.user.id, parsedPrinterId.id);
+            let agentPrinter = null;
             if (!printer || printer.company_id !== companyId) {
-                const agentPrinter = await agentprinterDb.getById(req.user.id, parsedPrinterId.id);
+                agentPrinter = await agentprinterDb.getById(req.user.id, parsedPrinterId.id);
                 if (agentPrinter) {
                     printer = agentPrinter;
                 } else {
                     return res.status(404).json({ error: 'Printer not found' });
                 }
+            } else if (printer.printeragentId != null) {
+                agentPrinter = printer;
             }
             if (printer.type && printer.type.toLowerCase() !== 'zpl') {
                 return res.status(400).json({ error: 'Printer is not a ZPL printer' });
@@ -425,42 +433,67 @@ export function register(app, basePath = '') {
                 return res.status(404).json({ error: 'Article not found' });
             }
 
-            // Extract and interpolate canvas objects
+            // Extract and interpolate canvas objects or raw ZPL
             const content = template.content;
-            const objects = Array.isArray(content?.objects)
-                ? content.objects
-                : Array.isArray(content)
-                    ? content
-                    : [];
+            let zplData;
 
-            const interpolatedObjects = objects.map(obj => {
-                const cloned = { ...obj };
-                if (typeof cloned.text === 'string') {
-                    cloned.text = interpolateString(cloned.text, article);
+            if (typeof content === 'string' && content.includes('^XA')) {
+                let interpolated = interpolateString(content, article);
+                if (parsedQuantity.id > 1) {
+                    interpolated = applyZplCopies(interpolated, parsedQuantity.id);
                 }
-                if (typeof cloned.code === 'string') {
-                    cloned.code = interpolateString(cloned.code, article);
+                zplData = interpolated;
+            } else {
+                const objects = Array.isArray(content?.objects)
+                    ? content.objects
+                    : Array.isArray(content)
+                        ? content
+                        : [];
+
+                const interpolatedObjects = objects.map(obj => {
+                    const cloned = { ...obj };
+                    if (typeof cloned.text === 'string') {
+                        cloned.text = interpolateString(cloned.text, article);
+                    }
+                    if (typeof cloned.code === 'string') {
+                        cloned.code = interpolateString(cloned.code, article);
+                    }
+                    return cloned;
+                });
+
+                const printPayload = await renderLabel({
+                    width: template.width,
+                    height: template.height,
+                    objects: interpolatedObjects,
+                });
+
+                zplData = await pngToZpl(printPayload, parsedQuantity.id);
+            }
+
+            if (agentPrinter) {
+                const job = await printerjobDb.create(req.user.id, {
+                    agentprinterId: agentPrinter.id,
+                    type: 'zpl',
+                    data: zplData,
+                });
+
+                if (job.printeragentId) {
+                    notifyAgentJob(job.printeragentId, 'created', job);
                 }
-                return cloned;
-            });
 
-            const printPayload = await renderLabel({
-                width: template.width,
-                height: template.height,
-                objects: interpolatedObjects,
-            });
+                emit('printerjob', { companyId, data: { job } });
+                return res.status(200).json({ success: true, printerjob: job });
+            }
 
-            // Mock network dispatch
-            const spoolKey = printer.address ? `${printer.address}_${printer.type}` : `agent_${printer.id}_${printer.type || 'zpl'}`;
+            // Fallback for legacy network printers with static IP / address
+            const spoolKey = printer.address ? `${printer.address}_${printer.type}` : `printer_${printer.id}_${printer.type || 'zpl'}`;
             const printDir = path.join(process.cwd(), 'print_spool', spoolKey);
             await fs.mkdir(printDir, { recursive: true });
             
-            for (let i = 0; i < parsedQuantity.id; i++) {
-                const timestamp = Date.now();
-                const filename = parsedQuantity.id > 1 ? `${timestamp}_${i + 1}.png` : `${timestamp}.png`;
-                const filePath = path.join(printDir, filename);
-                await fs.writeFile(filePath, printPayload);
-            }
+            const timestamp = Date.now();
+            const filename = `${timestamp}.zpl`;
+            const filePath = path.join(printDir, filename);
+            await fs.writeFile(filePath, zplData, 'utf8');
 
             res.status(200).json({ success: true });
         } catch (error) {

src/services/zplService.js

@@ -0,0 +1,80 @@
+import { createCanvas, loadImage } from 'canvas';
+
+/**
+ * Converts a PNG image buffer into Zebra ZPL II Graphic Field (^GFA) format.
+ * Uses Zebra's alternative compression scheme (ACS run-length encoding on hex)
+ * to minimize payload size over the network and serial/USB ports.
+ *
+ * @param {Buffer} pngBuffer - Rendered 1-bit or RGBA PNG buffer.
+ * @param {number} [quantity=1] - Number of copies to print (^PQ).
+ * @returns {Promise<string>} Full ZPL string ready to send to a Zebra printer.
+ */
+export async function pngToZpl(pngBuffer, quantity = 1) {
+    const img = await loadImage(pngBuffer);
+    const canvas = createCanvas(img.width, img.height);
+    const ctx = canvas.getContext('2d');
+    ctx.drawImage(img, 0, 0);
+    const imgData = ctx.getImageData(0, 0, img.width, img.height);
+    const { data, width: w, height: h } = imgData;
+
+    const bytesPerRow = Math.ceil(w / 8);
+    const totalBytes = bytesPerRow * h;
+    const buffer = new Uint8Array(totalBytes);
+
+    for (let y = 0; y < h; y++) {
+        for (let x = 0; x < w; x++) {
+            const idx = (y * w + x) * 4;
+            const r = data[idx];
+            const g = data[idx + 1];
+            const b = data[idx + 2];
+            const a = data[idx + 3];
+            // Ink threshold: non-transparent and dark pixels are black (1)
+            const isBlack = a > 128 && (r * 0.299 + g * 0.587 + b * 0.114) < 128;
+            if (isBlack) {
+                const byteIdx = y * bytesPerRow + Math.floor(x / 8);
+                const bitIdx = 7 - (x % 8);
+                buffer[byteIdx] |= 1 << bitIdx;
+            }
+        }
+    }
+
+    const hexMap = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0').toUpperCase());
+    let hex = '';
+    for (let i = 0; i < totalBytes; i++) {
+        hex += hexMap[buffer[i]];
+    }
+
+    // Zebra ACS run-length encoding:
+    // Repeated characters are replaced by letters:
+    // 'G'..'Y' = 1..19 repeats
+    // 'g'..'y' = 20..380 repeats (step 20)
+    // 'z' = 400 repeats
+    let acs = '';
+    const re = /([0-9A-F])\1{2,}/g;
+    let match = re.exec(hex);
+    let offset = 0;
+    while (match) {
+        acs += hex.substring(offset, match.index);
+        let l = match[0].length;
+        while (l >= 400) {
+            acs += 'z';
+            l -= 400;
+        }
+        if (l >= 20) {
+            acs += '_ghijklmnopqrstuvwxy'[Math.floor(l / 20)];
+            l = l % 20;
+        }
+        if (l) {
+            acs += '_GHIJKLMNOPQRSTUVWXY'[l];
+        }
+        acs += match[1];
+        offset = re.lastIndex;
+        match = re.exec(hex);
+    }
+    acs += hex.substring(offset);
+
+    const qty = Number(quantity);
+    const pq = Number.isInteger(qty) && qty > 1 ? `^PQ${qty}\n` : '';
+    return `^XA^PW${w}^LL${h}^LS0^FT0,0^GFA,${totalBytes},${totalBytes},${bytesPerRow},${acs}\n${pq}^XZ`;
+}
+