dikshiprintagent 1.0.0

package/NPM-PACKAGE.md

@@ -0,0 +1,48 @@
+# dikshiprintagent npm package
+
+Install after publishing (or install the generated `.tgz` file locally):
+
+```bash
+npm install dikshiprintagent
+```
+
+The package uses ES modules and works in modern browser build tools and Node.js 18+.
+
+```js
+import DikshiPrintAgent from 'dikshiprintagent';
+
+const agent = new DikshiPrintAgent({
+  token: 'TOKEN_FROM_THE_WINDOWS_TRAY_APP'
+});
+
+const { printers } = await agent.printers();
+const job = await agent.printText(printers[0].name, 'Hello from npm');
+await agent.wait(job.jobId);
+```
+
+ESC/POS receipt example:
+
+```js
+const receipt = DikshiPrintAgent.receiptBuilder({ width: 42 })
+  .center().bold().text('DIKSHI STORE\n').bold(false)
+  .line()
+  .row('Total', 'Rs. 100.00')
+  .cut()
+  .build();
+
+await agent.printEscPos('EPSON TM-T82', receipt);
+```
+
+Create the distributable package:
+
+```bash
+npm test
+npm pack
+```
+
+Publish (requires npm account access and ownership of the package name):
+
+```bash
+npm login
+npm publish
+```

package/README.md

@@ -0,0 +1,98 @@
+# Dikshi Print Agent V10
+
+Windows local print bridge for websites. Designed around Windows printer queues, so newly installed printers are discovered automatically when Windows has a working driver.
+
+Android/iOS remote printing through the optional secure relay is documented in [REMOTE-PRINTING.md](REMOTE-PRINTING.md).
+
+## V10 features
+- Windows tray application
+- Loopback-only HTTP API on `127.0.0.1:8181`
+- First-run 256-bit random API token
+- Origin allow-list/CORS protection
+- Dynamic installed-printer discovery and default-printer detection
+- Queued print jobs + job status/history
+- Text printing through Windows PrintDocument
+- Image printing (base64 PNG/JPG/BMP etc.)
+- RAW printing through Winspool (label languages / printer-native data)
+- ESC/POS uses the RAW path
+- PDF printing through Windows registered PDF `printto` handler
+- Direct PDF URL printing: agent downloads the PDF from an API URL and sends it to the selected printer
+- HTML printing through WebView2 with page size/orientation options
+- Invoice/receipt template printing from plain JSON data
+- QR and CODE128 barcode printing
+- ESC/POS receipt builder in the browser SDK
+- Persistent recent job history under `%APPDATA%\DikshiPrintAgent\job-history.json`
+- Local dashboard with printer list, HTML/text test print, and job history
+- Visual template designer at `/designer` with drag/drop fields and saved JSON layouts
+- Designer validation, version backups, locked layouts, resize handles, undo/redo, zoom, logo upload, and custom table columns
+- Dashboard/designer pages do not embed the API token; paste it from the tray menu before using protected actions
+- Daily logs under `%APPDATA%\DikshiPrintAgent\logs`
+- Start-with-Windows support
+- Browser JavaScript SDK + test page
+- Single-file self-contained `win-x64` publish
+- Inno Setup script included
+
+## Build
+Install the Microsoft .NET 8 SDK on the Windows development PC, then run `build-exe.bat`.
+Output: `DikshiPrintAgent-V10.exe` in the project root.
+
+## First run
+Run the EXE. It creates:
+`%APPDATA%\DikshiPrintAgent\config.json`
+
+Right-click the tray icon -> **Copy API Token**.
+Edit `AllowedOrigins` in config.json to include your websites, then restart the agent.
+Example:
+```json
+"AllowedOrigins": [
+  "https://erp.example.com",
+  "https://billing.example.com",
+  "http://localhost:*"
+]
+```
+Do not set `AllowAllOrigins=true` on production PCs unless you fully understand the security risk.
+
+## API
+- `GET /api/v1/health` (no token; health only)
+- `GET /api/v1/printers`
+- `GET /api/v1/jobs`
+- `GET /api/v1/jobs/{id}`
+- `GET /api/v1/templates`
+- `GET /api/v1/templates/{name}`
+- `POST /api/v1/templates`
+- `POST /api/v1/print/text`
+- `POST /api/v1/print/image`
+- `POST /api/v1/print/code`
+- `POST /api/v1/print/raw`
+- `POST /api/v1/print/escpos`
+- `POST /api/v1/print/pdf`
+- `POST /api/v1/print/pdf-url`
+- `POST /api/v1/print/html`
+- `POST /api/v1/print/template`
+- `POST /api/v1/print/designed-template`
+- WebSocket: `/ws?token=...`
+
+Authenticated REST requests require `X-Dikshi-Token`.
+
+### Print a PDF directly from an API URL
+Use this when your server API returns `application/pdf` as a downloadable file. The agent downloads the PDF locally, validates it, queues it, and prints through the existing PDF print handler.
+
+```bash
+curl -X POST "http://127.0.0.1:8181/api/v1/print/pdf-url" \
+  -H "Content-Type: application/json" \
+  -H "X-Dikshi-Token: YOUR_AGENT_TOKEN" \
+  -d "{\"printer\":\"YOUR_WINDOWS_PRINTER_NAME\",\"url\":\"https://dikshitech.ddns.net/kingmotorsapi/api/BookingEntry/DownloadBookingPdf/001/B00009AA\",\"documentName\":\"Booking_B00009AA.pdf\"}"
+```
+
+Browser SDK:
+```js
+await agent.printPdfUrl(printerName, bookingPdfUrl, {
+  documentName: 'Booking_B00009AA.pdf'
+});
+```
+
+## Important compatibility notes
+1. Generic printing works with printers exposed as valid Windows printer queues. Future printer models normally need only their Windows driver.
+2. RAW/ESC-POS requires the printer/driver to accept the command language being sent. There is no universal ESC/POS guarantee for every model.
+3. PDF `printto` relies on a Windows PDF application that implements the `printto` shell verb. For maximum unattended PDF reliability, a dedicated PDF rendering/printing engine should be embedded in a future signed enterprise build.
+4. An HTTPS website talking to a local agent can be affected by browser mixed-content/private-network policies. For strict enterprise/all-site deployment, use a trusted local TLS certificate or companion Chrome/Edge extension. This source keeps loopback HTTP intentionally simple and auditable.

package/npm/browser.js

@@ -0,0 +1,7 @@
+export { DikshiPrintAgent, DikshiReceiptBuilder, default } from './index.js';
+import { DikshiPrintAgent, DikshiReceiptBuilder } from './index.js';
+
+if (typeof window !== 'undefined') {
+  window.DikshiPrintAgent = DikshiPrintAgent;
+  window.DikshiReceiptBuilder = DikshiReceiptBuilder;
+}

package/npm/index.d.ts

@@ -0,0 +1,52 @@
+export interface AgentOptions {
+  token: string;
+  host?: string;
+  port?: number;
+  protocol?: 'http' | 'https';
+  fetch?: typeof fetch;
+}
+
+export type PrintOptions = Record<string, unknown>;
+export interface PrintJob { jobId?: string; status?: string; error?: string; [key: string]: unknown; }
+
+export class DikshiPrintAgent {
+  constructor(options: AgentOptions);
+  token: string;
+  base: string;
+  request(path: string, options?: RequestInit): Promise<any>;
+  health(): Promise<any>;
+  printers(): Promise<any>;
+  jobs(): Promise<any>;
+  job(id: string): Promise<PrintJob>;
+  templates(): Promise<any>;
+  template(name: string): Promise<any>;
+  saveTemplate(template: object): Promise<any>;
+  printText(printer: string, text: string, options?: PrintOptions): Promise<PrintJob>;
+  printRaw(printer: string, data: Uint8Array | string, options?: PrintOptions): Promise<PrintJob>;
+  printEscPos(printer: string, data: Uint8Array | string, options?: PrintOptions): Promise<PrintJob>;
+  printImage(printer: string, dataBase64: string, options?: PrintOptions): Promise<PrintJob>;
+  printCode(printer: string, value: string, options?: PrintOptions): Promise<PrintJob>;
+  printQr(printer: string, value: string, options?: PrintOptions): Promise<PrintJob>;
+  printBarcode(printer: string, value: string, options?: PrintOptions): Promise<PrintJob>;
+  printPdf(printer: string, dataBase64: string, options?: PrintOptions): Promise<PrintJob>;
+  printPdfUrl(printer: string, url: string, options?: PrintOptions): Promise<PrintJob>;
+  printHtml(printer: string, html: string, options?: PrintOptions): Promise<PrintJob>;
+  printTemplate(printer: string, templateData?: object): Promise<PrintJob>;
+  printDesignedTemplate(printer: string, templateName: string, data?: object, options?: PrintOptions): Promise<PrintJob>;
+  wait(jobId: string, timeoutMs?: number): Promise<PrintJob>;
+  static receiptBuilder(options?: ReceiptBuilderOptions): DikshiReceiptBuilder;
+}
+
+export interface ReceiptBuilderOptions { width?: number; encoding?: string; }
+export class DikshiReceiptBuilder {
+  constructor(options?: ReceiptBuilderOptions);
+  init(): this; bytes(...values: number[]): this; text(value?: unknown): this; line(char?: string): this;
+  feed(lines?: number): this; bold(on?: boolean): this; underline(on?: boolean): this;
+  size(mode?: 'normal' | 'double' | 'wide' | 'tall'): this; align(value?: 'left' | 'center' | 'right'): this;
+  left(): this; center(): this; right(): this; row(left: unknown, right: unknown): this;
+  item(name: unknown, qty: number, rate: number, amount?: number): this; qr(value: unknown, size?: number): this;
+  barcode(value: unknown, height?: number): this; openCashDrawer(): this; cut(partial?: boolean): this;
+  raw(data: Uint8Array | number[]): this; build(): Uint8Array;
+}
+
+export default DikshiPrintAgent;

package/npm/index.js

@@ -0,0 +1,135 @@
+/** JavaScript client for the Dikshi Print Agent HTTP API. */
+export class DikshiPrintAgent {
+  constructor({ token, host = '127.0.0.1', port = 8181, protocol = 'http', fetch: fetchImpl } = {}) {
+    if (!token) throw new Error('Dikshi Print Agent token is required');
+    this.token = token;
+    this.base = `${protocol}://${host}:${port}`;
+    this.fetch = fetchImpl || globalThis.fetch;
+    if (typeof this.fetch !== 'function') throw new Error('A fetch implementation is required');
+  }
+
+  async request(path, options = {}) {
+    const response = await this.fetch(this.base + path, {
+      ...options,
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Dikshi-Token': this.token,
+        ...(options.headers || {})
+      }
+    });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) throw new Error(data.error || `Print Agent HTTP ${response.status}`);
+    return data;
+  }
+
+  async health() {
+    const response = await this.fetch(this.base + '/api/v1/health');
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) throw new Error(data.error || `Print Agent HTTP ${response.status}`);
+    return data;
+  }
+
+  printers() { return this.request('/api/v1/printers'); }
+  jobs() { return this.request('/api/v1/jobs'); }
+  job(id) { return this.request('/api/v1/jobs/' + encodeURIComponent(id)); }
+  templates() { return this.request('/api/v1/templates'); }
+  template(name) { return this.request('/api/v1/templates/' + encodeURIComponent(name)); }
+  saveTemplate(template) { return this.request('/api/v1/templates', this._post(template)); }
+  printText(printer, text, options = {}) { return this.request('/api/v1/print/text', this._post({ printer, text, ...options })); }
+  printImage(printer, dataBase64, options = {}) { return this.request('/api/v1/print/image', this._post({ printer, dataBase64, ...options })); }
+  printCode(printer, value, options = {}) { return this.request('/api/v1/print/code', this._post({ printer, value, ...options })); }
+  printQr(printer, value, options = {}) { return this.printCode(printer, value, { type: 'QR', ...options }); }
+  printBarcode(printer, value, options = {}) { return this.printCode(printer, value, { type: 'CODE128', ...options }); }
+  printPdf(printer, dataBase64, options = {}) { return this.request('/api/v1/print/pdf', this._post({ printer, dataBase64, ...options })); }
+  printPdfUrl(printer, url, options = {}) { return this.request('/api/v1/print/pdf-url', this._post({ printer, url, ...options })); }
+  printHtml(printer, html, options = {}) { return this.request('/api/v1/print/html', this._post({ printer, html, ...options })); }
+  printTemplate(printer, templateData = {}) { return this.request('/api/v1/print/template', this._post({ printer, ...templateData })); }
+  printDesignedTemplate(printer, templateName, data = {}, options = {}) {
+    return this.request('/api/v1/print/designed-template', this._post({ printer, templateName, data, ...options }));
+  }
+  printRaw(printer, bytesOrBase64, options = {}) { return this._binary('/api/v1/print/raw', printer, bytesOrBase64, options); }
+  printEscPos(printer, bytesOrBase64, options = {}) { return this._binary('/api/v1/print/escpos', printer, bytesOrBase64, options); }
+
+  async wait(jobId, timeoutMs = 20000) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      const job = await this.job(jobId);
+      if (job.status === 'completed') return job;
+      if (job.status === 'failed') throw new Error(job.error || 'Print failed');
+      await new Promise(resolve => setTimeout(resolve, 300));
+    }
+    throw new Error('Print job timeout');
+  }
+
+  _post(value) { return { method: 'POST', body: JSON.stringify(value) }; }
+  _binary(path, printer, data, options) {
+    let dataBase64 = data;
+    if (data instanceof Uint8Array) dataBase64 = bytesToBase64(data);
+    return this.request(path, this._post({ printer, dataBase64, ...options }));
+  }
+
+  static receiptBuilder(options = {}) { return new DikshiReceiptBuilder(options); }
+}
+
+export class DikshiReceiptBuilder {
+  constructor({ width = 42, encoding = 'utf-8' } = {}) {
+    this.width = width;
+    this.encoding = encoding;
+    this.parts = [];
+    this.init();
+  }
+  init() { return this.bytes(0x1b, 0x40); }
+  bytes(...values) { this.parts.push(Uint8Array.from(values)); return this; }
+  text(value = '') { this.parts.push(new TextEncoder(this.encoding).encode(String(value))); return this; }
+  line(char = '-') { return this.text(String(char).repeat(this.width) + '\n'); }
+  feed(lines = 1) { return this.text('\n'.repeat(Math.max(1, lines))); }
+  bold(on = true) { return this.bytes(0x1b, 0x45, on ? 1 : 0); }
+  underline(on = true) { return this.bytes(0x1b, 0x2d, on ? 1 : 0); }
+  size(mode = 'normal') { return this.bytes(0x1d, 0x21, mode === 'double' ? 0x11 : mode === 'wide' ? 0x10 : mode === 'tall' ? 0x01 : 0x00); }
+  align(value = 'left') { return this.bytes(0x1b, 0x61, value === 'center' ? 1 : value === 'right' ? 2 : 0); }
+  left() { return this.align('left'); }
+  center() { return this.align('center'); }
+  right() { return this.align('right'); }
+  row(left, right) {
+    const a = String(left ?? '');
+    const b = String(right ?? '');
+    return this.text(a + ' '.repeat(Math.max(1, this.width - a.length - b.length)) + b + '\n');
+  }
+  item(name, qty, rate, amount = Number(qty || 0) * Number(rate || 0)) {
+    this.text(String(name ?? '') + '\n');
+    return this.row(`${qty} x ${Number(rate || 0).toFixed(2)}`, Number(amount || 0).toFixed(2));
+  }
+  qr(value, size = 6) {
+    const data = new TextEncoder(this.encoding).encode(String(value ?? ''));
+    const length = data.length + 3;
+    return this.align('center')
+      .bytes(0x1d, 0x28, 0x6b, 0x04, 0x00, 0x31, 0x41, 0x32, 0x00)
+      .bytes(0x1d, 0x28, 0x6b, 0x03, 0x00, 0x31, 0x43, Math.max(1, Math.min(16, size)))
+      .bytes(0x1d, 0x28, 0x6b, 0x03, 0x00, 0x31, 0x45, 0x31)
+      .bytes(0x1d, 0x28, 0x6b, length & 0xff, (length >> 8) & 0xff, 0x31, 0x50, 0x30)
+      .raw(data).bytes(0x1d, 0x28, 0x6b, 0x03, 0x00, 0x31, 0x51, 0x30).align('left');
+  }
+  barcode(value, height = 70) {
+    const data = new TextEncoder(this.encoding).encode(String(value ?? ''));
+    return this.align('center').bytes(0x1d, 0x68, Math.max(1, Math.min(255, height)))
+      .bytes(0x1d, 0x48, 0x02).bytes(0x1d, 0x6b, 0x49, data.length).raw(data).feed().align('left');
+  }
+  openCashDrawer() { return this.bytes(0x1b, 0x70, 0x00, 0x19, 0xfa); }
+  cut(partial = false) { return this.feed(3).bytes(0x1d, 0x56, partial ? 0x01 : 0x00); }
+  raw(data) { this.parts.push(data instanceof Uint8Array ? data : Uint8Array.from(data || [])); return this; }
+  build() {
+    const output = new Uint8Array(this.parts.reduce((sum, part) => sum + part.length, 0));
+    let offset = 0;
+    for (const part of this.parts) { output.set(part, offset); offset += part.length; }
+    return output;
+  }
+}
+
+function bytesToBase64(bytes) {
+  if (typeof Buffer !== 'undefined') return Buffer.from(bytes).toString('base64');
+  let binary = '';
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+
+export default DikshiPrintAgent;

package/npm/test/sdk.test.mjs

@@ -0,0 +1,29 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import DikshiPrintAgent, { DikshiReceiptBuilder } from '../index.js';
+
+test('requires a token', () => {
+  assert.throws(() => new DikshiPrintAgent(), /token is required/);
+});
+
+test('sends authenticated print requests', async () => {
+  let request;
+  const agent = new DikshiPrintAgent({
+    token: 'secret',
+    fetch: async (url, options) => {
+      request = { url, options };
+      return { ok: true, json: async () => ({ jobId: '123' }) };
+    }
+  });
+  const result = await agent.printText('Printer 1', 'Hello');
+  assert.equal(result.jobId, '123');
+  assert.equal(request.url, 'http://127.0.0.1:8181/api/v1/print/text');
+  assert.equal(request.options.headers['X-Dikshi-Token'], 'secret');
+  assert.deepEqual(JSON.parse(request.options.body), { printer: 'Printer 1', text: 'Hello' });
+});
+
+test('builds ESC/POS bytes', () => {
+  const output = new DikshiReceiptBuilder({ width: 10 }).text('Hi').cut().build();
+  assert.ok(output instanceof Uint8Array);
+  assert.ok(output.length > 5);
+});

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "dikshiprintagent",
+  "version": "1.0.0",
+  "description": "JavaScript SDK for the Dikshi Print Agent local Windows printing service",
+  "keywords": [
+    "printing",
+    "silent-print",
+    "escpos",
+    "windows-printer",
+    "dikshi"
+  ],
+  "license": "UNLICENSED",
+  "type": "module",
+  "main": "./npm/index.js",
+  "module": "./npm/index.js",
+  "types": "./npm/index.d.ts",
+  "browser": "./npm/browser.js",
+  "exports": {
+    ".": {
+      "types": "./npm/index.d.ts",
+      "import": "./npm/index.js",
+      "default": "./npm/index.js"
+    },
+    "./browser": "./npm/browser.js"
+  },
+  "files": [
+    "npm",
+    "README.md",
+    "NPM-PACKAGE.md"
+  ],
+  "scripts": {
+    "test": "node --test npm/test",
+    "prepack": "npm test"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}