@bobfrankston/brother-label 1.0.1

package/brother-print.ts

@@ -0,0 +1,697 @@
+#!/usr/bin/env node
+import { Jimp, loadFont, measureText, measureTextHeight, HorizontalAlign, VerticalAlign } from "jimp";
+import { program } from "commander";
+import { exec, spawn } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { renderHtmlFile, closeBrowser } from "./render.js";
+import QRCode from "qrcode";
+
+const __dirname = import.meta.dirname;
+
+interface PrintOptions {
+    printer: string;
+    fontSize: number;
+    width: number;
+    height: number;
+    tapeMm: number;
+}
+
+interface Config {
+    defaultTape?: string;
+    defaultPrinter?: string;
+}
+
+const CONFIG_PATH = path.join(os.homedir(), ".brother-label.json");
+
+function loadConfig(): Config {
+    try {
+        if (fs.existsSync(CONFIG_PATH)) {
+            return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+        }
+    } catch (err) {
+        // Ignore config errors
+    }
+    return {};
+}
+
+function saveConfig(config: Config): void {
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+// Available font sizes in jimp
+const FONT_SIZES = [128, 64, 32, 16, 14, 12, 10, 8];
+
+async function loadFontBySize(size: number): Promise<any> {
+    const fontDir = path.join(__dirname, "node_modules/@jimp/plugin-print/fonts/open-sans");
+    const fontFolder = `open-sans-${size}-black`;
+    const fontPath = path.join(fontDir, fontFolder, `${fontFolder}.fnt`);
+    return loadFont(fontPath);
+}
+
+async function createLabelImage(text: string, options: PrintOptions): Promise<Buffer> {
+    const lines = text.split("\\n").join("\n");
+    const targetHeight = options.height;
+
+    // Use largest font for best quality, then scale down
+    let font = await loadFontBySize(128);
+
+    // Render text at large size first
+    const textWidth = measureText(font, lines);
+    const textHeight = measureTextHeight(font, lines, textWidth + 100);
+
+    // Create image for text with small padding
+    const padding = 10;
+    const imgWidth = textWidth + padding * 2;
+    const imgHeight = textHeight + padding * 2;
+
+    const tempImage = new Jimp({ width: imgWidth, height: imgHeight, color: 0xffffffff });
+
+    tempImage.print({
+        font: font,
+        x: padding,
+        y: padding,
+        text: lines,
+    });
+
+    // Scale to fit tape height (tape sizes already account for printable area)
+    const scale = targetHeight / imgHeight;
+    const finalWidth = Math.round(imgWidth * scale);
+    const finalHeight = Math.round(imgHeight * scale);
+
+    tempImage.resize({ w: finalWidth, h: finalHeight });
+
+    // Create final image sized to content with small horizontal padding
+    const hPadding = Math.round(targetHeight * 0.2);  // ~20% of height as side margins
+    const outputWidth = finalWidth + hPadding * 2;
+    const image = new Jimp({ width: outputWidth, height: targetHeight, color: 0xffffffff });
+
+    // Center both horizontally and vertically
+    const xOffset = hPadding;
+    const yOffset = Math.round((targetHeight - finalHeight) / 2);
+    image.composite(tempImage, xOffset, yOffset);
+
+    return image.getBuffer("image/png");
+}
+
+async function createQrLabelImage(data: string, options: PrintOptions, labelText?: string): Promise<Buffer> {
+    const targetHeight = options.height;
+    const qrSize = Math.floor(targetHeight * 0.95);  // QR code is 95% of tape height
+
+    // Margins in mm converted to pixels at PRINT_DPI
+    // Left margin ~2mm, right margin ~4mm to account for printer feed
+    const pxPerMm = PRINT_DPI / 25.4;
+    const leftMargin = Math.round(2 * pxPerMm);
+    const rightMargin = Math.round(4 * pxPerMm);
+
+    // Generate QR code as PNG buffer at high resolution
+    const qrBuffer = await QRCode.toBuffer(data, {
+        type: "png",
+        width: qrSize,
+        margin: 0,
+        errorCorrectionLevel: "M",
+        color: { dark: "#000000", light: "#ffffff" },
+    });
+
+    const qrImage = await Jimp.read(qrBuffer);
+
+    if (!labelText) {
+        // QR only - create minimal label with margins
+        const outputWidth = leftMargin + qrSize + rightMargin;
+        const image = new Jimp({ width: outputWidth, height: targetHeight, color: 0xffffffff });
+        const yOffset = Math.floor((targetHeight - qrSize) / 2);
+        image.composite(qrImage, leftMargin, yOffset);
+        return image.getBuffer("image/png");
+    }
+
+    // QR + text label
+    const font = await loadFontBySize(64);
+    const textWidth = measureText(font, labelText);
+    const textHeight = measureTextHeight(font, labelText, textWidth + 50);
+
+    // Scale text to fit beside QR
+    const maxTextHeight = targetHeight * 0.8;
+    const textScale = Math.min(1, maxTextHeight / textHeight);
+    const scaledTextWidth = Math.round(textWidth * textScale);
+    const scaledTextHeight = Math.round(textHeight * textScale);
+
+    // Create text image
+    const textImg = new Jimp({ width: textWidth + 20, height: textHeight + 20, color: 0xffffffff });
+    textImg.print({ font, x: 10, y: 10, text: labelText });
+    if (textScale < 1) {
+        textImg.resize({ w: scaledTextWidth, h: scaledTextHeight });
+    }
+
+    // Compose final image: QR on left, text on right
+    const gap = Math.floor(targetHeight * 0.15);
+    const outputWidth = leftMargin + qrSize + gap + scaledTextWidth + rightMargin;
+    const image = new Jimp({ width: outputWidth, height: targetHeight, color: 0xffffffff });
+
+    const qrY = Math.floor((targetHeight - qrSize) / 2);
+    image.composite(qrImage, leftMargin, qrY);
+
+    const textY = Math.floor((targetHeight - scaledTextHeight) / 2);
+    image.composite(textImg, leftMargin + qrSize + gap, textY);
+
+    return image.getBuffer("image/png");
+}
+
+async function printImage(imagePath: string, printerName: string, tapeMm: number): Promise<void> {
+    // Map tape mm to Brother CustomMediaSize for PrintTicket
+    const mediaOptions: Record<number, { name: string; width: number }> = {
+        6: { name: "CustomMediaSize257", width: 5900 },
+        9: { name: "CustomMediaSize258", width: 9000 },
+        12: { name: "CustomMediaSize259", width: 11900 },
+        18: { name: "CustomMediaSize260", width: 18100 },
+        24: { name: "CustomMediaSize261", width: 24000 },
+    };
+    const media = mediaOptions[tapeMm] || mediaOptions[12];
+
+    return new Promise((resolve, reject) => {
+        const psScript = `
+Add-Type -AssemblyName System.Drawing
+Add-Type -AssemblyName System.Printing
+Add-Type -AssemblyName ReachFramework
+Add-Type -AssemblyName PresentationCore
+
+$img = [System.Drawing.Image]::FromFile('${imagePath.replace(/\\/g, "\\\\")}')
+
+# Calculate label dimensions in microns (using ${PRINT_DPI} DPI source images)
+$labelLengthMicrons = [int]($img.Width / ${PRINT_DPI}.0 * 25400) + 3000
+$tapeWidthMicrons = ${media.width}
+
+# Image dimensions in WPF units (1/96 inch) - convert from ${PRINT_DPI} DPI source
+$imgWidthWpf = $img.Width / ${PRINT_DPI}.0 * 96
+$imgHeightWpf = $img.Height / ${PRINT_DPI}.0 * 96
+
+Write-Host "Using ${tapeMm}mm tape, label length: $([int]($labelLengthMicrons/1000))mm"
+
+# Build PrintTicket XML
+$ticketXml = @"
+<?xml version="1.0" encoding="UTF-8"?>
+<psf:PrintTicket xmlns:psf="http://schemas.microsoft.com/windows/2003/08/printing/printschemaframework"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" version="1"
+    xmlns:psk="http://schemas.microsoft.com/windows/2003/08/printing/printschemakeywords"
+    xmlns:ns0001="http://schemas.brother.info/mfc/printing/2006/11/printschemakeywords">
+  <psf:Feature name="psk:PageMediaSize">
+    <psf:Option name="ns0001:${media.name}">
+      <psf:ScoredProperty name="psk:MediaSizeWidth">
+        <psf:Value xsi:type="xsd:integer">${media.width}</psf:Value>
+      </psf:ScoredProperty>
+      <psf:ScoredProperty name="psk:MediaSizeHeight">
+        <psf:ParameterRef name="psk:PageMediaSizeMediaSizeHeight" />
+      </psf:ScoredProperty>
+    </psf:Option>
+  </psf:Feature>
+  <psf:ParameterInit name="psk:PageMediaSizeMediaSizeHeight">
+    <psf:Value xsi:type="xsd:integer">$labelLengthMicrons</psf:Value>
+  </psf:ParameterInit>
+  <psf:Feature name="psk:PageOrientation">
+    <psf:Option name="psk:Landscape" />
+  </psf:Feature>
+  <psf:Feature name="ns0001:PageRollFeedToEndOfSheet">
+    <psf:Option name="ns0001:FeedToImageEdge" />
+  </psf:Feature>
+  <psf:Feature name="psk:PageMediaType">
+    <psf:Option name="psk:Label" />
+  </psf:Feature>
+  <psf:Feature name="ns0001:JobRollCutSheet">
+    <psf:Option name="ns0001:CutSheet" />
+  </psf:Feature>
+</psf:PrintTicket>
+"@
+
+$xmlBytes = [System.Text.Encoding]::UTF8.GetBytes($ticketXml)
+$memStream = New-Object System.IO.MemoryStream(,$xmlBytes)
+$ticket = New-Object System.Printing.PrintTicket($memStream)
+
+# Get print queue and create XPS document writer with our ticket
+$server = New-Object System.Printing.LocalPrintServer
+$queue = $server.GetPrintQueue('${printerName}')
+
+# Create temp XPS file
+$xpsPath = [System.IO.Path]::GetTempFileName() + ".xps"
+
+# Page size in WPF units (96 dpi) - convert from microns
+$pageWidth = $labelLengthMicrons / 25400.0 * 96  # length is horizontal
+$pageHeight = $tapeWidthMicrons / 25400.0 * 96   # tape width is vertical
+
+# Create XPS document
+$package = [System.IO.Packaging.Package]::Open($xpsPath, [System.IO.FileMode]::Create)
+$xpsDoc = New-Object System.Windows.Xps.Packaging.XpsDocument($package)
+$writer = [System.Windows.Xps.Packaging.XpsDocument]::CreateXpsDocumentWriter($xpsDoc)
+
+# Create visual with image
+$visual = New-Object System.Windows.Media.DrawingVisual
+$dc = $visual.RenderOpen()
+
+# Load image as WPF bitmap
+$bitmapImg = New-Object System.Windows.Media.Imaging.BitmapImage
+$bitmapImg.BeginInit()
+$bitmapImg.UriSource = New-Object System.Uri('${imagePath.replace(/\\/g, "\\\\")}')
+$bitmapImg.EndInit()
+
+# Draw image centered vertically on page
+$yOffset = ($pageHeight - $imgHeightWpf) / 2
+$rect = New-Object System.Windows.Rect(0, $yOffset, $imgWidthWpf, $imgHeightWpf)
+$dc.DrawImage($bitmapImg, $rect)
+$dc.Close()
+
+# Write to XPS with page size
+$pageSize = New-Object System.Printing.PageMediaSize($pageWidth, $pageHeight)
+$writer.Write($visual, $ticket)
+
+$xpsDoc.Close()
+$package.Close()
+$img.Dispose()
+
+# Print the XPS file with our ticket
+$xpsDocForPrint = New-Object System.Windows.Xps.Packaging.XpsDocument($xpsPath, [System.IO.FileAccess]::Read)
+$seq = $xpsDocForPrint.GetFixedDocumentSequence()
+
+$xpsWriter = [System.Printing.PrintQueue]::CreateXpsDocumentWriter($queue)
+$xpsWriter.Write($seq, $ticket)
+
+$xpsDocForPrint.Close()
+Remove-Item $xpsPath -ErrorAction SilentlyContinue
+
+Write-Host "Print complete"
+`;
+
+        const ps = spawn("powershell", ["-Command", psScript], { stdio: "pipe" });
+
+        let stdout = "";
+        let stderr = "";
+        ps.stdout.on("data", (data) => {
+            stdout += data.toString();
+        });
+        ps.stderr.on("data", (data) => {
+            stderr += data.toString();
+        });
+
+        ps.on("close", (code) => {
+            if (stdout) console.log(stdout.trim());
+            if (code === 0) {
+                resolve();
+            } else {
+                reject(new Error(`Print failed: ${stderr}`));
+            }
+        });
+
+        ps.on("error", (err) => {
+            reject(new Error(`Failed to print: ${err.message}`));
+        });
+    });
+}
+
+async function printLabel(text: string, options: PrintOptions): Promise<void> {
+    // Create temp file for the image
+    const tempDir = os.tmpdir();
+    const tempFile = path.join(tempDir, `label-${Date.now()}.png`);
+
+    try {
+        const imageBuffer = await createLabelImage(text, options);
+        fs.writeFileSync(tempFile, imageBuffer);
+
+        await printImage(tempFile, options.printer, options.tapeMm);
+    } finally {
+        // Clean up temp file
+        if (fs.existsSync(tempFile)) {
+            fs.unlinkSync(tempFile);
+        }
+    }
+}
+
+async function printHtmlLabel(htmlPath: string, options: PrintOptions): Promise<void> {
+    const tempDir = os.tmpdir();
+    const tempFile = path.join(tempDir, `label-html-${Date.now()}.png`);
+
+    try {
+        // CSS mm units use 96 DPI. Convert tape mm to CSS pixels, then scale up.
+        // For 12mm tape: 12mm * 3.78 px/mm = ~45px CSS height
+        // deviceScaleFactor of 300/96 ≈ 3.125 gives us 300 DPI output
+        const cssPixelsPerMm = 96 / 25.4;  // ~3.78
+        const viewportHeight = Math.round(options.tapeMm * cssPixelsPerMm);
+        const viewportWidth = Math.round(viewportHeight * 5);  // ~5:1 aspect for labels
+        const scaleFactor = PRINT_DPI / 96;  // Scale CSS pixels to print DPI
+
+        const renderedBuffer = await renderHtmlFile(htmlPath, {
+            width: viewportWidth,
+            height: viewportHeight,
+            deviceScaleFactor: scaleFactor,
+            keepScale: true,  // Keep full resolution for printing
+        });
+
+        // Add margins for printer feed (3mm left, 4mm right)
+        const pxPerMm = PRINT_DPI / 25.4;
+        const leftMargin = Math.round(3 * pxPerMm);
+        const rightMargin = Math.round(4 * pxPerMm);
+
+        const rendered = await Jimp.read(renderedBuffer);
+        const paddedWidth = rendered.width + leftMargin + rightMargin;
+        const padded = new Jimp({ width: paddedWidth, height: rendered.height, color: 0xffffffff });
+        padded.composite(rendered, leftMargin, 0);
+
+        const imageBuffer = await padded.getBuffer("image/png");
+        fs.writeFileSync(tempFile, imageBuffer);
+
+        await printImage(tempFile, options.printer, options.tapeMm);
+    } finally {
+        if (fs.existsSync(tempFile)) {
+            fs.unlinkSync(tempFile);
+        }
+        await closeBrowser();
+    }
+}
+
+async function listPrinters(): Promise<void> {
+    return new Promise((resolve, reject) => {
+        exec('powershell -Command "Get-Printer | Where-Object { $_.Name -like \'*Brother*\' -or $_.Name -like \'*PT*\' } | Select-Object -ExpandProperty Name"',
+            (error, stdout, stderr) => {
+                if (error) {
+                    reject(new Error(`Failed to list printers: ${stderr}`));
+                    return;
+                }
+                const printers = stdout.trim().split("\n").filter(p => p.trim());
+                if (printers.length === 0) {
+                    console.log("No Brother printers found");
+                } else {
+                    console.log("Brother printers:");
+                    printers.forEach(p => console.log(`  ${p.trim()}`));
+                }
+                resolve();
+            });
+    });
+}
+
+async function detectTapeSize(printerName: string): Promise<number | null> {
+    // First check config file for user-specified tape size
+    const config = loadConfig();
+    if (config.defaultTape) {
+        const mm = parseInt(config.defaultTape.replace("mm", ""), 10);
+        if (!isNaN(mm) && TAPE_SIZES[`${mm}mm`]) {
+            return mm;
+        }
+    }
+
+    // Fall back to WMI query (may be stale after tape change)
+    return new Promise((resolve) => {
+        exec(`powershell -Command "(Get-WmiObject Win32_PrinterConfiguration -Filter \\"Name='${printerName}'\\").PaperWidth"`,
+            (error, stdout) => {
+                if (error || !stdout.trim()) {
+                    resolve(null);
+                    return;
+                }
+                // PaperWidth is in tenths of mm
+                const tenthsMm = parseInt(stdout.trim(), 10);
+                if (isNaN(tenthsMm)) {
+                    resolve(null);
+                    return;
+                }
+                const mm = Math.round(tenthsMm / 10);
+                resolve(mm);
+            });
+    });
+}
+
+// Default printer name
+const DEFAULT_PRINTER = "Brother PT-P710BT";
+
+// Label sizes for P-touch tapes at 300 DPI (high quality)
+// PT-P710BT has 180 DPI print head; 300 DPI source ensures max quality
+// Printable area from printer: 0.71" height for 24mm tape, proportional for others
+const PRINT_DPI = 300;
+const TAPE_SIZES: Record<string, { width: number; height: number; mm: number }> = {
+    "6mm": { width: 1137, height: 56, mm: 6 },     // 3.79" x 0.19" @ 300 DPI
+    "9mm": { width: 1137, height: 84, mm: 9 },     // 3.79" x 0.28" @ 300 DPI
+    "12mm": { width: 1137, height: 113, mm: 12 },  // 3.79" x 0.38" @ 300 DPI
+    "18mm": { width: 1137, height: 169, mm: 18 },  // 3.79" x 0.56" @ 300 DPI
+    "24mm": { width: 1137, height: 213, mm: 24 },  // 3.79" x 0.71" @ 300 DPI
+};
+
+program
+    .name("brother-print")
+    .description("Print labels to Brother P-touch and QL label printers")
+    .version("1.0.0");
+
+program
+    .command("print <text>")
+    .description("Print a text label (use \\\\n for newlines)")
+    .option("-p, --printer <name>", "Printer name", DEFAULT_PRINTER)
+    .option("-t, --tape <size>", "Tape size: 6mm, 9mm, 12mm, 18mm, 24mm, or 'auto'", "auto")
+    .option("-w, --width <px>", "Custom width in pixels")
+    .option("-H, --img-height <px>", "Custom height in pixels")
+    .action(async (text: string, opts) => {
+        try {
+            let tapeMm: number;
+            let tapeSize;
+
+            if (opts.tape === "auto") {
+                const detected = await detectTapeSize(opts.printer);
+                if (detected) {
+                    tapeMm = detected;
+                    tapeSize = TAPE_SIZES[`${detected}mm`] || TAPE_SIZES["24mm"];
+                    console.log(`Detected ${detected}mm tape`);
+                } else {
+                    console.log("Could not detect tape, using 24mm");
+                    tapeMm = 24;
+                    tapeSize = TAPE_SIZES["24mm"];
+                }
+            } else {
+                tapeSize = TAPE_SIZES[opts.tape] || TAPE_SIZES["24mm"];
+                tapeMm = tapeSize.mm;
+            }
+
+            const options: PrintOptions = {
+                printer: opts.printer,
+                fontSize: 32,
+                width: opts.width ? parseInt(opts.width, 10) : tapeSize.width,    // label length
+                height: opts.imgHeight ? parseInt(opts.imgHeight, 10) : tapeSize.height,  // tape height (printable)
+                tapeMm: tapeMm,
+            };
+
+            await printLabel(text, options);
+            console.log("Label printed successfully");
+        } catch (err) {
+            console.error(`Error: ${(err as Error).message}`);
+            process.exit(1);
+        }
+    });
+
+program
+    .command("list")
+    .description("List connected Brother printers")
+    .action(async () => {
+        try {
+            await listPrinters();
+        } catch (err) {
+            console.error(`Error: ${(err as Error).message}`);
+            process.exit(1);
+        }
+    });
+
+program
+    .command("image <file>")
+    .description("Print an image file (PNG, JPG, BMP)")
+    .option("-p, --printer <name>", "Printer name", DEFAULT_PRINTER)
+    .option("-t, --tape <size>", "Tape size: 6mm, 9mm, 12mm, 18mm, 24mm, or 'auto'", "auto")
+    .action(async (file: string, opts) => {
+        try {
+            let tapeMm: number;
+            let tapeSize;
+
+            if (opts.tape === "auto") {
+                const detected = await detectTapeSize(opts.printer);
+                if (detected) {
+                    tapeMm = detected;
+                    tapeSize = TAPE_SIZES[`${detected}mm`] || TAPE_SIZES["24mm"];
+                    console.log(`Detected ${detected}mm tape`);
+                } else {
+                    console.log("Could not detect tape, using 24mm");
+                    tapeMm = 24;
+                    tapeSize = TAPE_SIZES["24mm"];
+                }
+            } else {
+                tapeSize = TAPE_SIZES[opts.tape] || TAPE_SIZES["24mm"];
+                tapeMm = tapeSize.mm;
+            }
+
+            const absolutePath = path.resolve(file);
+            await printImage(absolutePath, opts.printer, tapeMm);
+            console.log("Image printed successfully");
+        } catch (err) {
+            console.error(`Error: ${(err as Error).message}`);
+            process.exit(1);
+        }
+    });
+
+program
+    .command("html <file>")
+    .description("Print an HTML file as a label")
+    .option("-p, --printer <name>", "Printer name", DEFAULT_PRINTER)
+    .option("-t, --tape <size>", "Tape size: 6mm, 9mm, 12mm, 18mm, 24mm, or 'auto'", "auto")
+    .action(async (file: string, opts) => {
+        try {
+            let tapeMm: number;
+            let tapeSize;
+
+            if (opts.tape === "auto") {
+                const detected = await detectTapeSize(opts.printer);
+                if (detected) {
+                    tapeMm = detected;
+                    tapeSize = TAPE_SIZES[`${detected}mm`] || TAPE_SIZES["24mm"];
+                    console.log(`Detected ${detected}mm tape`);
+                } else {
+                    console.log("Could not detect tape, using 24mm");
+                    tapeMm = 24;
+                    tapeSize = TAPE_SIZES["24mm"];
+                }
+            } else {
+                tapeSize = TAPE_SIZES[opts.tape] || TAPE_SIZES["24mm"];
+                tapeMm = tapeSize.mm;
+            }
+
+            const options: PrintOptions = {
+                printer: opts.printer,
+                fontSize: 32,
+                width: tapeSize.width,    // label length
+                height: tapeSize.height,  // tape height (printable)
+                tapeMm: tapeMm,
+            };
+
+            await printHtmlLabel(file, options);
+            console.log("HTML label printed successfully");
+        } catch (err) {
+            console.error(`Error: ${(err as Error).message}`);
+            process.exit(1);
+        }
+    });
+
+program
+    .command("preview <text>")
+    .description("Save label as PNG without printing")
+    .option("-f, --font-size <size>", "Font size (16 or 32)", "32")
+    .option("-t, --tape <size>", "Tape size: 6mm, 9mm, 12mm, 18mm, 24mm", "12mm")
+    .option("-w, --width <px>", "Custom width in pixels")
+    .option("-H, --img-height <px>", "Custom height in pixels")
+    .option("-o, --output <file>", "Output file path", "label-preview.png")
+    .action(async (text: string, opts) => {
+        try {
+            const tapeSize = TAPE_SIZES[opts.tape] || TAPE_SIZES["12mm"];
+            const options: PrintOptions = {
+                printer: "",
+                fontSize: parseInt(opts.fontSize, 10),
+                width: opts.width ? parseInt(opts.width, 10) : tapeSize.width,    // label length
+                height: opts.imgHeight ? parseInt(opts.imgHeight, 10) : tapeSize.height,  // tape height
+                tapeMm: tapeSize.mm,
+            };
+
+            const imageBuffer = await createLabelImage(text, options);
+            fs.writeFileSync(opts.output, imageBuffer);
+            console.log(`Preview saved to ${opts.output}`);
+        } catch (err) {
+            console.error(`Error: ${(err as Error).message}`);
+            process.exit(1);
+        }
+    });
+
+program
+    .command("qr <data>")
+    .description("Print a QR code label")
+    .option("-p, --printer <name>", "Printer name", DEFAULT_PRINTER)
+    .option("-t, --tape <size>", "Tape size: 6mm, 9mm, 12mm, 18mm, 24mm, or 'auto'", "auto")
+    .option("-l, --label <text>", "Optional text label beside QR code")
+    .option("-o, --output <file>", "Save to file instead of printing")
+    .action(async (data: string, opts) => {
+        try {
+            let tapeMm: number;
+            let tapeSize;
+
+            if (opts.tape === "auto") {
+                const detected = await detectTapeSize(opts.printer);
+                if (detected) {
+                    tapeMm = detected;
+                    tapeSize = TAPE_SIZES[`${detected}mm`] || TAPE_SIZES["24mm"];
+                    console.log(`Detected ${detected}mm tape`);
+                } else {
+                    console.log("Could not detect tape, using 24mm");
+                    tapeMm = 24;
+                    tapeSize = TAPE_SIZES["24mm"];
+                }
+            } else {
+                tapeSize = TAPE_SIZES[opts.tape] || TAPE_SIZES["24mm"];
+                tapeMm = tapeSize.mm;
+            }
+
+            const options: PrintOptions = {
+                printer: opts.printer,
+                fontSize: 32,
+                width: tapeSize.width,
+                height: tapeSize.height,
+                tapeMm: tapeMm,
+            };
+
+            const imageBuffer = await createQrLabelImage(data, options, opts.label);
+
+            if (opts.output) {
+                fs.writeFileSync(opts.output, imageBuffer);
+                console.log(`QR label saved to ${opts.output}`);
+            } else {
+                const tempDir = os.tmpdir();
+                const tempFile = path.join(tempDir, `qr-label-${Date.now()}.png`);
+                try {
+                    fs.writeFileSync(tempFile, imageBuffer);
+                    await printImage(tempFile, options.printer, options.tapeMm);
+                    console.log("QR label printed successfully");
+                } finally {
+                    if (fs.existsSync(tempFile)) {
+                        fs.unlinkSync(tempFile);
+                    }
+                }
+            }
+        } catch (err) {
+            console.error(`Error: ${(err as Error).message}`);
+            process.exit(1);
+        }
+    });
+
+program
+    .command("config")
+    .description("Set default tape size and printer (stored in ~/.brother-label.json)")
+    .option("-t, --tape <size>", "Set default tape size: 6mm, 9mm, 12mm, 18mm, 24mm")
+    .option("-p, --printer <name>", "Set default printer name")
+    .option("-s, --show", "Show current configuration")
+    .action((opts) => {
+        const config = loadConfig();
+
+        if (opts.show || (!opts.tape && !opts.printer)) {
+            console.log("Current configuration:");
+            console.log(`  Config file: ${CONFIG_PATH}`);
+            console.log(`  Default tape: ${config.defaultTape || "(not set - will use WMI detection)"}`);
+            console.log(`  Default printer: ${config.defaultPrinter || DEFAULT_PRINTER}`);
+            console.log("\nAvailable tape sizes: 6mm, 9mm, 12mm, 18mm, 24mm");
+            return;
+        }
+
+        if (opts.tape) {
+            const tape = opts.tape.endsWith("mm") ? opts.tape : `${opts.tape}mm`;
+            if (!TAPE_SIZES[tape]) {
+                console.error(`Invalid tape size: ${opts.tape}`);
+                console.error("Valid sizes: 6mm, 9mm, 12mm, 18mm, 24mm");
+                process.exit(1);
+            }
+            config.defaultTape = tape;
+            console.log(`Default tape set to: ${tape}`);
+        }
+
+        if (opts.printer) {
+            config.defaultPrinter = opts.printer;
+            console.log(`Default printer set to: ${opts.printer}`);
+        }
+
+        saveConfig(config);
+        console.log(`Configuration saved to ${CONFIG_PATH}`);
+    });
+
+program.parse();