@ecobridge.xyz/devicemanager 3.1.0 → 3.2.0

package/ts/protocols/protocol.ipp.ts

@@ -164,6 +164,8 @@ export interface IIppPrinterCapabilities {
   // Document formats
   documentFormatSupported: string[];
   documentFormatDefault?: string;
+  /** Whether the printer advertises Apple's Universal Raster Format. */
+  airPrintSupported: boolean;
 
   // Media
   mediaSizeSupported: string[];
@@ -573,6 +575,10 @@ class IppDecoder {
         return date;
       }
 
+      case TAG_VALUE.TEXT_WITH_LANGUAGE:
+      case TAG_VALUE.NAME_WITH_LANGUAGE:
+        return this.readLanguageTaggedString(length);
+
       case TAG_VALUE.NO_VALUE:
       case TAG_VALUE.UNKNOWN:
       case TAG_VALUE.UNSUPPORTED:
@@ -584,6 +590,20 @@ class IppDecoder {
         return this.readString(length);
     }
   }
+
+  private readLanguageTaggedString(length: number): string {
+    const value = this.buffer.subarray(this.offset, this.offset + length);
+    this.offset += length;
+    if (value.length < 4) return value.toString('utf-8');
+
+    const languageLength = value.readUInt16BE(0);
+    const textLengthOffset = 2 + languageLength;
+    if (textLengthOffset + 2 > value.length) return value.toString('utf-8');
+    const textLength = value.readUInt16BE(textLengthOffset);
+    const textOffset = textLengthOffset + 2;
+    if (textOffset + textLength > value.length) return value.toString('utf-8');
+    return value.toString('utf-8', textOffset, textOffset + textLength);
+  }
 }
 
 // ============================================================================
@@ -745,6 +765,8 @@ export class IppClient {
     const printerStateString = printerState === PRINTER_STATE.IDLE ? 'idle' :
       printerState === PRINTER_STATE.PROCESSING ? 'processing' : 'stopped';
 
+    const documentFormatSupported = getStringArray('document-format-supported');
+
     return {
       printerName: getString('printer-name', 'Unknown Printer'),
       printerInfo: getString('printer-info') || undefined,
@@ -757,8 +779,9 @@ export class IppClient {
       printerIsAcceptingJobs: getBool('printer-is-accepting-jobs', true),
       queuedJobCount: getNumber('queued-job-count', 0),
 
-      documentFormatSupported: getStringArray('document-format-supported'),
+      documentFormatSupported,
       documentFormatDefault: getString('document-format-default') || undefined,
+      airPrintSupported: documentFormatSupported.includes('image/urf'),
 
       mediaSizeSupported: getStringArray('media-supported'),
       mediaDefault: getString('media-default') || undefined,

package/ts/providers/index.ts

@@ -0,0 +1,7 @@
+export {
+  SmbShareProvider,
+  type ISmbDocumentEvent,
+  type ISmbServerAdapter,
+  type ISmbShareProviderDependencies,
+  type ISmbShareProviderOptions,
+} from './provider.smb.js';

package/ts/providers/provider.smb.ts

@@ -0,0 +1,326 @@
+import {
+  SambaServer,
+  type ISambaAuthOptions,
+  type ISambaClientOptions,
+  type ISambaServerOptions,
+  type ISambaServerStartResult,
+  type ISambaServerStatus,
+} from '@push.rocks/smartsamba';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as plugins from '../plugins.js';
+import { ObservableEventEmitter } from '../events/index.js';
+
+export interface ISmbShareProviderOptions extends ISambaServerOptions {
+  /** Interval used to inspect share contents for changes. */
+  pollIntervalMs?: number;
+  /** Time a file must remain unchanged before it is emitted as ready. */
+  settleTimeMs?: number;
+  /** Emit pre-existing regular files after startup. Defaults to false. */
+  emitExistingDocuments?: boolean;
+}
+
+export interface ISmbDocumentEvent {
+  shareName: string;
+  relativePath: string;
+  absolutePath: string;
+  size: number;
+  createdAt: Date;
+  modifiedAt: Date;
+  detectedAt: Date;
+}
+
+export interface ISmbServerAdapter {
+  start(): Promise<ISambaServerStartResult>;
+  stop(): Promise<void>;
+  status(): Promise<ISambaServerStatus>;
+  getConnectionOptions(auth?: Partial<ISambaAuthOptions>): ISambaClientOptions;
+}
+
+export interface ISmbShareProviderDependencies {
+  serverFactory?: (options: ISambaServerOptions) => ISmbServerAdapter;
+  now?: () => number;
+}
+
+type TPendingFileEvent = 'arrived' | 'changed';
+
+interface ITrackedFile {
+  shareName: string;
+  relativePath: string;
+  absolutePath: string;
+  size: number;
+  createdMs: number;
+  modifiedMs: number;
+  lastChangedMs: number;
+  emitted: boolean;
+  pending?: TPendingFileEvent;
+}
+
+const DEFAULT_POLL_INTERVAL_MS = 250;
+const DEFAULT_SETTLE_TIME_MS = 1000;
+
+/**
+ * Hosts local folders through SMB and emits settled document arrivals.
+ */
+export class SmbShareProvider extends ObservableEventEmitter {
+  private readonly server: ISmbServerAdapter;
+  private readonly shares: ISambaServerOptions['shares'];
+  private readonly pollIntervalMs: number;
+  private readonly settleTimeMs: number;
+  private readonly emitExistingDocuments: boolean;
+  private readonly now: () => number;
+  private readonly trackedFiles = new Map<string, ITrackedFile>();
+  private pollTimer?: ReturnType<typeof setInterval>;
+  private scanPromise?: Promise<void>;
+  private startResult?: ISambaServerStartResult;
+
+  public readonly documents$ = this.events$.pipe(
+    plugins.rxjs.filter((event) => event.name === 'document:arrived'),
+    plugins.rxjs.map((event) => event.args[0] as ISmbDocumentEvent)
+  );
+
+  constructor(
+    options: ISmbShareProviderOptions,
+    dependencies: ISmbShareProviderDependencies = {}
+  ) {
+    super();
+    const {
+      pollIntervalMs = DEFAULT_POLL_INTERVAL_MS,
+      settleTimeMs = DEFAULT_SETTLE_TIME_MS,
+      emitExistingDocuments = false,
+      ...serverOptions
+    } = options;
+    if (
+      !Number.isFinite(pollIntervalMs) ||
+      !Number.isFinite(settleTimeMs) ||
+      pollIntervalMs <= 0 ||
+      settleTimeMs < 0
+    ) {
+      throw new Error('SMB poll interval must be positive and settle time must not be negative');
+    }
+    this.shares = serverOptions.shares;
+    this.pollIntervalMs = pollIntervalMs;
+    this.settleTimeMs = settleTimeMs;
+    this.emitExistingDocuments = emitExistingDocuments;
+    this.now = dependencies.now ?? Date.now;
+    this.server = dependencies.serverFactory?.(serverOptions) ?? new SambaServer(serverOptions);
+  }
+
+  public get running(): boolean {
+    return this.startResult !== undefined;
+  }
+
+  public async start(): Promise<ISambaServerStartResult> {
+    if (this.startResult) return this.startResult;
+
+    try {
+      await this.prepareShareDirectories();
+      await this.initializeTrackedFiles();
+      this.startResult = await this.server.start();
+      this.pollTimer = setInterval(() => this.queueScan(), this.pollIntervalMs);
+      this.pollTimer.unref?.();
+      this.emit('started', this.startResult);
+      return this.startResult;
+    } catch (error) {
+      this.emit('provider:error', error);
+      throw error;
+    }
+  }
+
+  public async stop(): Promise<void> {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = undefined;
+    }
+    await this.scanPromise;
+    if (!this.startResult) return;
+
+    try {
+      await this.server.stop();
+    } finally {
+      this.startResult = undefined;
+      this.trackedFiles.clear();
+      this.emit('stopped');
+    }
+  }
+
+  public async status(): Promise<ISambaServerStatus> {
+    if (!this.startResult) {
+      return { running: false, shares: this.shares.map((share) => share.name) };
+    }
+    return this.server.status();
+  }
+
+  public getConnectionOptions(auth?: Partial<ISambaAuthOptions>): ISambaClientOptions {
+    return this.server.getConnectionOptions(auth);
+  }
+
+  /** Runs an immediate share scan. Useful after an external notification. */
+  public async scanNow(): Promise<void> {
+    await this.queueScan();
+  }
+
+  private async prepareShareDirectories(): Promise<void> {
+    for (const share of this.shares) {
+      if (share.createIfMissing !== false) {
+        await fs.mkdir(path.resolve(share.path), { recursive: true });
+      }
+    }
+  }
+
+  private async initializeTrackedFiles(): Promise<void> {
+    this.trackedFiles.clear();
+    const now = this.now();
+    for (const share of this.shares) {
+      const files = await listRegularFiles(path.resolve(share.path));
+      for (const file of files) {
+        const tracked = this.toTrackedFile(share.name, file, now);
+        tracked.emitted = !this.emitExistingDocuments;
+        tracked.pending = this.emitExistingDocuments ? 'arrived' : undefined;
+        this.trackedFiles.set(trackedFileKey(share.name, file.absolutePath), tracked);
+      }
+    }
+  }
+
+  private queueScan(): Promise<void> {
+    if (this.scanPromise) return this.scanPromise;
+    const scanPromise = this.scanShares()
+      .catch((error) => {
+        this.emit('provider:error', error);
+      })
+      .finally(() => {
+        this.scanPromise = undefined;
+      });
+    this.scanPromise = scanPromise;
+    return scanPromise;
+  }
+
+  private async scanShares(): Promise<void> {
+    const now = this.now();
+    const seenFiles = new Set<string>();
+
+    for (const share of this.shares) {
+      const rootPath = path.resolve(share.path);
+      const files = await listRegularFiles(rootPath);
+      for (const file of files) {
+        const key = trackedFileKey(share.name, file.absolutePath);
+        seenFiles.add(key);
+        const existing = this.trackedFiles.get(key);
+        if (!existing) {
+          this.trackedFiles.set(
+            key,
+            this.toTrackedFile(share.name, file, now, 'arrived')
+          );
+          continue;
+        }
+
+        if (existing.size !== file.size || existing.modifiedMs !== file.modifiedMs) {
+          existing.size = file.size;
+          existing.createdMs = file.createdMs;
+          existing.modifiedMs = file.modifiedMs;
+          existing.lastChangedMs = now;
+          existing.pending = existing.emitted ? 'changed' : 'arrived';
+          continue;
+        }
+
+        if (existing.pending && now - existing.lastChangedMs >= this.settleTimeMs) {
+          const eventName = existing.pending === 'arrived'
+            ? 'document:arrived'
+            : 'document:changed';
+          existing.pending = undefined;
+          existing.emitted = true;
+          this.emit(eventName, this.toDocumentEvent(existing, now));
+        }
+      }
+    }
+
+    for (const [key, tracked] of this.trackedFiles) {
+      if (seenFiles.has(key)) continue;
+      this.trackedFiles.delete(key);
+      if (tracked.emitted) {
+        this.emit('document:removed', this.toDocumentEvent(tracked, now));
+      }
+    }
+  }
+
+  private toTrackedFile(
+    shareName: string,
+    file: IRegularFile,
+    now: number,
+    pending?: TPendingFileEvent
+  ): ITrackedFile {
+    return {
+      shareName,
+      relativePath: file.relativePath,
+      absolutePath: file.absolutePath,
+      size: file.size,
+      createdMs: file.createdMs,
+      modifiedMs: file.modifiedMs,
+      lastChangedMs: now,
+      emitted: false,
+      pending,
+    };
+  }
+
+  private toDocumentEvent(file: ITrackedFile, now: number): ISmbDocumentEvent {
+    return {
+      shareName: file.shareName,
+      relativePath: file.relativePath,
+      absolutePath: file.absolutePath,
+      size: file.size,
+      createdAt: new Date(file.createdMs),
+      modifiedAt: new Date(file.modifiedMs),
+      detectedAt: new Date(now),
+    };
+  }
+}
+
+interface IRegularFile {
+  relativePath: string;
+  absolutePath: string;
+  size: number;
+  createdMs: number;
+  modifiedMs: number;
+}
+
+function trackedFileKey(shareName: string, absolutePath: string): string {
+  return `${shareName}\0${absolutePath}`;
+}
+
+async function listRegularFiles(rootPath: string): Promise<IRegularFile[]> {
+  const files: IRegularFile[] = [];
+  await walkDirectory(rootPath, rootPath, files);
+  return files;
+}
+
+async function walkDirectory(
+  rootPath: string,
+  directoryPath: string,
+  files: IRegularFile[]
+): Promise<void> {
+  let entries;
+  try {
+    entries = await fs.readdir(directoryPath, { withFileTypes: true });
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return;
+    throw error;
+  }
+
+  for (const entry of entries) {
+    const absolutePath = path.join(directoryPath, entry.name);
+    if (entry.isDirectory()) {
+      await walkDirectory(rootPath, absolutePath, files);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+
+    const stats = await fs.stat(absolutePath);
+    files.push({
+      relativePath: path.relative(rootPath, absolutePath).split(path.sep).join('/'),
+      absolutePath,
+      size: stats.size,
+      createdMs: stats.birthtimeMs,
+      modifiedMs: stats.mtimeMs,
+    });
+  }
+}

package/dist_ts/protocols/protocol.ipp.old.d.ts

@@ -1,45 +0,0 @@
-import type { IPrinterCapabilities, IPrintOptions, IPrintJob } from '../interfaces/index.js';
-/**
- * IPP protocol wrapper using the ipp npm package
- */
-export declare class IppProtocol {
-    private printerUrl;
-    private printer;
-    constructor(address: string, port: number, path?: string);
-    /**
-     * Get printer attributes/capabilities
-     */
-    getAttributes(): Promise<IPrinterCapabilities>;
-    /**
-     * Print a document
-     */
-    print(data: Buffer, options?: IPrintOptions): Promise<IPrintJob>;
-    /**
-     * Get all jobs
-     */
-    getJobs(): Promise<IPrintJob[]>;
-    /**
-     * Get specific job info
-     */
-    getJobInfo(jobId: number): Promise<IPrintJob>;
-    /**
-     * Cancel a job
-     */
-    cancelJob(jobId: number): Promise<void>;
-    /**
-     * Check if printer is available
-     */
-    checkAvailability(): Promise<boolean>;
-    /**
-     * Build IPP print message from options
-     */
-    private buildPrintMessage;
-    /**
-     * Parse printer capabilities from attributes
-     */
-    private parseCapabilities;
-    /**
-     * Parse job info from attributes
-     */
-    private parseJobInfo;
-}