@livedesk/hub 0.1.0 → 0.1.2

package/src/filesystem/transfer-jobs.js

@@ -0,0 +1,229 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import { setImmediate as yieldToEventLoop } from 'node:timers/promises';
+
+const CHUNK_BYTES = 512 * 1024;
+const JOB_RETENTION_MS = 10 * 60 * 1000;
+
+function snapshot(job) {
+  return {
+    jobId: job.jobId,
+    state: job.state,
+    totalFiles: job.totalFiles,
+    completedFiles: job.completedFiles,
+    totalBytes: job.totalBytes,
+    sentBytes: job.sentBytes,
+    currentPath: job.currentPath || '',
+    targetCount: job.deviceIds.length,
+    failedTargets: [...job.failedTargets].map(deviceId => ({ deviceId, error: job.targetErrors.get(deviceId) || 'transfer-failed' })),
+    error: job.error || null,
+    createdAt: job.createdAt,
+    updatedAt: job.updatedAt,
+    completedAt: job.completedAt || null
+  };
+}
+
+function markUpdated(job) {
+  job.updatedAt = new Date().toISOString();
+}
+
+export class HubTransferJobs {
+  constructor({ filesystem, remoteHub, maxConcurrent = 2 } = {}) {
+    this.filesystem = filesystem;
+    this.remoteHub = remoteHub;
+    this.maxConcurrent = Math.max(1, Number(maxConcurrent) || 2);
+    this.jobs = new Map();
+    this.queue = [];
+    this.running = 0;
+  }
+
+  create({ itemIds = [], deviceIds = [], remoteDirectory = '', files = null, onComplete = null } = {}) {
+    const targets = [...new Set((Array.isArray(deviceIds) ? deviceIds : []).map(value => String(value || '').trim()).filter(Boolean))].slice(0, 240);
+    if (targets.length === 0) throw new Error('no-target-devices');
+    const job = {
+      jobId: `job_${crypto.randomBytes(14).toString('base64url')}`,
+      state: 'queued',
+      itemIds: [...new Set((Array.isArray(itemIds) ? itemIds : []).map(value => String(value || '').trim()).filter(Boolean))],
+      files,
+      deviceIds: targets,
+      remoteDirectory: String(remoteDirectory || '').replace(/[\0\r\n\t]/g, ' ').trim().slice(0, 600),
+      totalFiles: 0,
+      completedFiles: 0,
+      totalBytes: 0,
+      sentBytes: 0,
+      currentPath: '',
+      failedTargets: new Set(),
+      targetErrors: new Map(),
+      error: '',
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      completedAt: '',
+      cancelled: false,
+      currentStream: null,
+      onComplete
+    };
+    this.jobs.set(job.jobId, job);
+    this.queue.push(job);
+    this.pump();
+    return snapshot(job);
+  }
+
+  get(jobId) {
+    this.prune();
+    const job = this.jobs.get(String(jobId || ''));
+    return job ? snapshot(job) : null;
+  }
+
+  list({ activeOnly = false } = {}) {
+    this.prune();
+    return [...this.jobs.values()]
+      .filter(job => !activeOnly || ['scanning', 'queued', 'sending'].includes(job.state))
+      .sort((left, right) => right.createdAt.localeCompare(left.createdAt))
+      .map(snapshot);
+  }
+
+  cancel(jobId) {
+    const job = this.jobs.get(String(jobId || ''));
+    if (!job) return null;
+    if (['completed', 'partially-failed', 'failed', 'cancelled'].includes(job.state)) return snapshot(job);
+    job.cancelled = true;
+    job.state = 'cancelled';
+    job.error = 'transfer-cancelled';
+    if (job.currentStream) job.currentStream.destroy();
+    markUpdated(job);
+    return snapshot(job);
+  }
+
+  pump() {
+    while (this.running < this.maxConcurrent && this.queue.length > 0) {
+      const job = this.queue.shift();
+      if (!job || job.cancelled) continue;
+      this.running += 1;
+      void this.run(job).finally(() => {
+        this.running -= 1;
+        this.pump();
+      });
+    }
+  }
+
+  async run(job) {
+    try {
+      job.state = 'scanning';
+      markUpdated(job);
+      const scan = job.files
+        ? { files: job.files, totalBytes: job.files.reduce((sum, file) => sum + Number(file.size || 0), 0) }
+        : await this.filesystem.scan(job.itemIds);
+      if (job.cancelled) return;
+      job.totalFiles = scan.files.length;
+      job.totalBytes = scan.totalBytes;
+      job.state = 'sending';
+      markUpdated(job);
+      if (scan.files.length === 0) {
+        job.state = 'completed';
+        job.completedAt = new Date().toISOString();
+        markUpdated(job);
+        await this.finishCallback(job, true);
+        return;
+      }
+
+      for (const file of scan.files) {
+        if (job.cancelled) return;
+        job.currentPath = file.relativePath;
+        markUpdated(job);
+        await this.sendFile(job, file);
+        job.completedFiles += 1;
+        markUpdated(job);
+      }
+
+      if (job.cancelled) return;
+      job.state = job.failedTargets.size === 0 ? 'completed' : 'partially-failed';
+      job.completedAt = new Date().toISOString();
+      job.currentPath = '';
+      if (job.failedTargets.size > 0) job.error = 'one-or-more-targets-failed';
+      markUpdated(job);
+      await this.finishCallback(job, job.state === 'completed');
+    } catch (error) {
+      if (job.cancelled) return;
+      job.state = job.failedTargets.size > 0 ? 'partially-failed' : 'failed';
+      job.error = error instanceof Error ? error.message : String(error);
+      job.completedAt = new Date().toISOString();
+      job.currentPath = '';
+      markUpdated(job);
+      await this.finishCallback(job, false);
+    }
+  }
+
+  async sendFile(job, file) {
+    const activeTargets = () => job.deviceIds.filter(deviceId => !job.failedTargets.has(deviceId));
+    if (Number(file.size || 0) === 0) {
+      await this.sendChunk(job, file, 0, Buffer.alloc(0), true, activeTargets());
+      return;
+    }
+    const stream = fs.createReadStream(file.absolutePath, { highWaterMark: CHUNK_BYTES });
+    job.currentStream = stream;
+    let offset = 0;
+    try {
+      for await (const chunk of stream) {
+        if (job.cancelled) return;
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        const final = offset + buffer.length >= Number(file.size || 0);
+        const targets = activeTargets();
+        if (targets.length === 0) throw new Error('all-targets-failed');
+        await this.sendChunk(job, file, offset, buffer, final, targets);
+        offset += buffer.length;
+        job.sentBytes += buffer.length;
+        markUpdated(job);
+        await yieldToEventLoop();
+      }
+    } finally {
+      job.currentStream = null;
+    }
+  }
+
+  async sendChunk(job, file, offset, buffer, final, targets) {
+    for (const deviceId of targets) {
+      if (job.cancelled) return;
+      const result = this.remoteHub.sendCommand(deviceId, {
+        command: 'file.transfer.chunk',
+        payload: {
+          transferId: job.jobId,
+          remoteDirectory: job.remoteDirectory,
+          name: file.name,
+          relativePath: file.relativePath,
+          offset,
+          totalBytes: Number(file.size || 0),
+          final,
+          dataBase64: buffer.toString('base64'),
+          lastModified: Number(file.modifiedMs || 0) || 0,
+          requestedAt: new Date().toISOString()
+        }
+      });
+      if (!result?.ok) {
+        job.failedTargets.add(deviceId);
+        job.targetErrors.set(deviceId, String(result?.error || 'device-not-connected'));
+      }
+    }
+  }
+
+  async finishCallback(job, completed) {
+    if (typeof job.onComplete !== 'function') return;
+    try {
+      await job.onComplete({ completed, job: snapshot(job) });
+    } catch (error) {
+      job.error = error instanceof Error ? error.message : String(error);
+      markUpdated(job);
+    }
+  }
+
+  prune() {
+    const threshold = Date.now() - JOB_RETENTION_MS;
+    for (const [id, job] of this.jobs) {
+      const createdAt = Date.parse(job.createdAt);
+      if (job.completedAt && Number.isFinite(createdAt) && createdAt < threshold) this.jobs.delete(id);
+    }
+  }
+}
+
+export function createHubTransferJobs(options) {
+  return new HubTransferJobs(options);
+}

package/src/lzo1x.js

@@ -0,0 +1,109 @@
+function requireInput(input, index, length) {
+  if (length < 0 || index < 0 || index + length > input.length) {
+    throw new Error('Invalid LZO1X block: input overrun.');
+  }
+}
+
+function readExtendedLength(input, state, basis) {
+  let zeroBytes = 0;
+  while (true) {
+    requireInput(input, state.inputIndex, 1);
+    if (input[state.inputIndex] !== 0) break;
+    zeroBytes += 1;
+    state.inputIndex += 1;
+  }
+  const length = zeroBytes * 255 + basis + input[state.inputIndex];
+  state.inputIndex += 1;
+  return length;
+}
+
+function copyLiteral(input, state, output, length) {
+  requireInput(input, state.inputIndex, length);
+  if (state.outputIndex + length > output.length) {
+    throw new Error('Invalid LZO1X block: output overrun.');
+  }
+  output.set(input.subarray(state.inputIndex, state.inputIndex + length), state.outputIndex);
+  state.inputIndex += length;
+  state.outputIndex += length;
+}
+
+export function decodeLzo1xBlock(input, outputLength) {
+  if (!(input instanceof Uint8Array) || input.length < 3 || outputLength < 0) {
+    throw new Error('Invalid LZO1X block.');
+  }
+  const output = new Uint8Array(outputLength);
+  const cursor = { inputIndex: 0, outputIndex: 0 };
+  let state = 0;
+  let matchLength = 0;
+  if (input[cursor.inputIndex] >= 22) {
+    const length = input[cursor.inputIndex] - 17;
+    cursor.inputIndex += 1;
+    copyLiteral(input, cursor, output, length);
+    state = 4;
+  } else if (input[cursor.inputIndex] >= 18) {
+    state = input[cursor.inputIndex] - 17;
+    cursor.inputIndex += 1;
+    copyLiteral(input, cursor, output, state);
+  }
+  while (true) {
+    requireInput(input, cursor.inputIndex, 1);
+    const instruction = input[cursor.inputIndex++];
+    let nextState;
+    let matchIndex;
+    if ((instruction & 0xc0) !== 0) {
+      requireInput(input, cursor.inputIndex, 1);
+      matchIndex = cursor.outputIndex - ((input[cursor.inputIndex] << 3) + ((instruction >> 2) & 7) + 1);
+      cursor.inputIndex += 1;
+      matchLength = (instruction >> 5) + 1;
+      nextState = instruction & 3;
+    } else if ((instruction & 0x20) !== 0) {
+      matchLength = (instruction & 0x1f) + 2;
+      if (matchLength === 2) matchLength += readExtendedLength(input, cursor, 31);
+      requireInput(input, cursor.inputIndex, 2);
+      const encoded = input[cursor.inputIndex] | (input[cursor.inputIndex + 1] << 8);
+      cursor.inputIndex += 2;
+      matchIndex = cursor.outputIndex - ((encoded >> 2) + 1);
+      nextState = encoded & 3;
+    } else if ((instruction & 0x10) !== 0) {
+      matchLength = (instruction & 7) + 2;
+      if (matchLength === 2) matchLength += readExtendedLength(input, cursor, 7);
+      requireInput(input, cursor.inputIndex, 2);
+      const encoded = input[cursor.inputIndex] | (input[cursor.inputIndex + 1] << 8);
+      cursor.inputIndex += 2;
+      matchIndex = cursor.outputIndex - (((instruction & 8) << 11) + (encoded >> 2));
+      nextState = encoded & 3;
+      if (matchIndex === cursor.outputIndex) break;
+      matchIndex -= 0x4000;
+    } else if (state === 0) {
+      let length = instruction + 3;
+      if (length === 3) length += readExtendedLength(input, cursor, 15);
+      copyLiteral(input, cursor, output, length);
+      state = 4;
+      continue;
+    } else if (state !== 4) {
+      requireInput(input, cursor.inputIndex, 1);
+      nextState = instruction & 3;
+      matchIndex = cursor.outputIndex - ((instruction >> 2) + (input[cursor.inputIndex] << 2) + 1);
+      cursor.inputIndex += 1;
+      matchLength = 2;
+    } else {
+      requireInput(input, cursor.inputIndex, 1);
+      nextState = instruction & 3;
+      matchIndex = cursor.outputIndex - ((instruction >> 2) + (input[cursor.inputIndex] << 2) + 2049);
+      cursor.inputIndex += 1;
+      matchLength = 3;
+    }
+    if (matchIndex < 0 || cursor.outputIndex + matchLength + nextState > output.length) {
+      throw new Error('Invalid LZO1X block: lookbehind overrun.');
+    }
+    for (let index = 0; index < matchLength; index += 1) {
+      output[cursor.outputIndex++] = output[matchIndex++];
+    }
+    state = nextState;
+    copyLiteral(input, cursor, output, nextState);
+  }
+  if (matchLength !== 3 || cursor.inputIndex !== input.length || cursor.outputIndex !== output.length) {
+    throw new Error('Invalid LZO1X block: incomplete output.');
+  }
+  return output;
+}