@livedesk/hub 0.1.3 → 0.1.5

package/src/captures/capture-store.js

@@ -0,0 +1,252 @@
+import { appendFile, mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import { createHash, randomUUID } from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
+
+const KINDS = new Set(['screenshot', 'recording', 'last-30s', 'timelapse']);
+const MIME_EXTENSIONS = new Map([
+  ['image/png', '.png'],
+  ['video/webm', '.webm']
+]);
+const MAX_INDEX_RECORDS = 500;
+
+function captureRoot(dataDir) {
+  return path.join(dataDir || path.join(os.homedir(), '.livedesk'), 'captures');
+}
+
+function safeName(value, fallback = 'capture') {
+  const normalized = String(value || '')
+    .replace(/[\0\r\n\\/]+/g, '-')
+    .replace(/[^a-zA-Z0-9._ -]/g, '')
+    .trim()
+    .replace(/\s+/g, '-')
+    .slice(0, 160);
+  return normalized || fallback;
+}
+
+function normalizeMimeType(value, fallback) {
+  const mimeType = String(value || fallback || '').split(';')[0].trim().toLowerCase();
+  return mimeType || fallback;
+}
+
+function normalizeTarget(value) {
+  const target = value && typeof value === 'object' ? value : {};
+  return {
+    type: String(target.type || 'wall').trim().slice(0, 32),
+    deviceIds: Array.isArray(target.deviceIds)
+      ? target.deviceIds.map(item => String(item || '').trim()).filter(Boolean).slice(0, 500)
+      : [],
+    monitorIndex: Number.isInteger(Number(target.monitorIndex)) ? Number(target.monitorIndex) : undefined,
+    label: safeName(target.label, 'Wall')
+  };
+}
+
+function publicRecord(record) {
+  const { filePath, ...publicValue } = record;
+  return publicValue;
+}
+
+async function atomicJson(filePath, value) {
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+  await rename(tempPath, filePath);
+}
+
+export class CaptureStore {
+  constructor({ dataDir } = {}) {
+    this.root = captureRoot(dataDir);
+    this.indexPath = path.join(this.root, 'index.json');
+    this.sessions = new Map();
+    this.index = null;
+  }
+
+  async initialize() {
+    await Promise.all(['images', 'recordings', 'timelapses', '.tmp'].map(folder =>
+      mkdir(path.join(this.root, folder), { recursive: true })));
+    try {
+      this.index = JSON.parse(await readFile(this.indexPath, 'utf8'));
+    } catch {
+      this.index = { captures: [] };
+    }
+    if (!Array.isArray(this.index.captures)) this.index.captures = [];
+    await this._cleanupTempFiles();
+  }
+
+  async ready() {
+    if (!this.index) await this.initialize();
+    return this;
+  }
+
+  async addBuffer(buffer, metadata = {}) {
+    await this.ready();
+    const bytes = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer || []);
+    const kind = KINDS.has(metadata.kind) ? metadata.kind : 'screenshot';
+    const mimeType = normalizeMimeType(metadata.mimeType, kind === 'screenshot' ? 'image/png' : 'video/webm');
+    if (!MIME_EXTENSIONS.has(mimeType)) {
+      throw Object.assign(new Error('capture-mime-type-unsupported'), { status: 415 });
+    }
+    const extension = MIME_EXTENSIONS.get(mimeType) || (kind === 'screenshot' ? '.png' : '.webm');
+    const fileNameBase = safeName(metadata.fileName, `LiveDesk_${kind}`);
+    const fileName = fileNameBase.toLowerCase().endsWith(extension) ? fileNameBase : `${fileNameBase}${extension}`;
+    const id = randomUUID();
+    const folder = kind === 'screenshot' ? 'images' : kind === 'timelapse' ? 'timelapses' : 'recordings';
+    const filePath = path.join(this.root, folder, `${id}${extension}`);
+    await writeFile(filePath, bytes, { mode: 0o600 });
+    try {
+      const record = await this._record({
+        id,
+        kind,
+        fileName,
+        mimeType,
+        sizeBytes: bytes.length,
+        durationMs: Number(metadata.durationMs) > 0 ? Number(metadata.durationMs) : undefined,
+        createdAt: new Date().toISOString(),
+        target: normalizeTarget(metadata.target),
+        sha256: createHash('sha256').update(bytes).digest('hex'),
+        filePath
+      });
+      return publicRecord(record);
+    } catch (error) {
+      await rm(filePath, { force: true });
+      throw error;
+    }
+  }
+
+  async createSession(metadata = {}) {
+    await this.ready();
+    const kind = metadata.kind === 'timelapse' ? 'timelapse' : 'recording';
+    const mimeType = normalizeMimeType(metadata.mimeType, 'video/webm');
+    if (mimeType !== 'video/webm') {
+      throw Object.assign(new Error('capture-mime-type-unsupported'), { status: 415 });
+    }
+    const sessionId = randomUUID();
+    const tempPath = path.join(this.root, '.tmp', `${sessionId}.webm.part`);
+    await writeFile(tempPath, Buffer.alloc(0), { mode: 0o600 });
+    const fileNameBase = safeName(metadata.fileName, `LiveDesk_${kind}`);
+    const session = {
+      sessionId,
+      kind,
+      fileName: fileNameBase.toLowerCase().endsWith('.webm') ? fileNameBase : `${fileNameBase}.webm`,
+      mimeType,
+      target: normalizeTarget(metadata.target),
+      tempPath,
+      nextSequence: 0,
+      received: new Set(),
+      sizeBytes: 0,
+      startedAt: Date.now()
+    };
+    this.sessions.set(sessionId, session);
+    return { sessionId, kind, fileName: session.fileName };
+  }
+
+  async appendSessionChunk(sessionId, sequence, buffer) {
+    await this.ready();
+    const session = this.sessions.get(String(sessionId || ''));
+    if (!session) throw Object.assign(new Error('capture-session-not-found'), { status: 404 });
+    if (!Number.isInteger(sequence) || sequence < 0) {
+      throw Object.assign(new Error('capture-sequence-invalid'), { status: 400 });
+    }
+    if (session.received.has(sequence)) return { duplicate: true, sequence, sizeBytes: session.sizeBytes };
+    if (sequence !== session.nextSequence) {
+      throw Object.assign(new Error(`capture-sequence-gap:${session.nextSequence}`), { status: 409 });
+    }
+    const bytes = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer || []);
+    await appendFile(session.tempPath, bytes);
+    session.received.add(sequence);
+    session.nextSequence += 1;
+    session.sizeBytes += bytes.length;
+    return { duplicate: false, sequence, sizeBytes: session.sizeBytes };
+  }
+
+  async finalizeSession(sessionId, durationMs) {
+    await this.ready();
+    const session = this.sessions.get(String(sessionId || ''));
+    if (!session) throw Object.assign(new Error('capture-session-not-found'), { status: 404 });
+    if (session.nextSequence === 0) throw Object.assign(new Error('capture-session-empty'), { status: 400 });
+    const extension = '.webm';
+    const folder = session.kind === 'timelapse' ? 'timelapses' : 'recordings';
+    const finalPath = path.join(this.root, folder, `${session.sessionId}${extension}`);
+    await rename(session.tempPath, finalPath);
+    try {
+      const bytes = await readFile(finalPath);
+      const record = await this._record({
+        id: session.sessionId,
+        kind: session.kind,
+        fileName: session.fileName,
+        mimeType: session.mimeType,
+        sizeBytes: bytes.length,
+        durationMs: Number(durationMs) > 0 ? Number(durationMs) : undefined,
+        createdAt: new Date().toISOString(),
+        target: session.target,
+        sha256: createHash('sha256').update(bytes).digest('hex'),
+        filePath: finalPath
+      });
+      this.sessions.delete(session.sessionId);
+      return publicRecord(record);
+    } catch (error) {
+      await rm(finalPath, { force: true });
+      throw error;
+    }
+  }
+
+  async cancelSession(sessionId) {
+    const session = this.sessions.get(String(sessionId || ''));
+    if (session) {
+      this.sessions.delete(session.sessionId);
+      await rm(session.tempPath, { force: true }).catch(() => undefined);
+    }
+  }
+
+  async list() {
+    await this.ready();
+    return this.index.captures.map(publicRecord);
+  }
+
+  async get(id) {
+    await this.ready();
+    return this.index.captures.find(item => item.id === String(id || '')) || null;
+  }
+
+  async remove(id) {
+    await this.ready();
+    const index = this.index.captures.findIndex(item => item.id === String(id || ''));
+    if (index < 0) return false;
+    const [record] = this.index.captures.splice(index, 1);
+    await rm(this.resolveFilePath(record), { force: true });
+    await atomicJson(this.indexPath, { captures: this.index.captures });
+    return true;
+  }
+
+  resolveFilePath(record) {
+    if (record?.filePath) return record.filePath;
+    const folder = record?.kind === 'screenshot' ? 'images' : record?.kind === 'timelapse' ? 'timelapses' : 'recordings';
+    const extension = record?.mimeType === 'image/png' ? '.png' : '.webm';
+    return path.join(this.root, folder, `${safeName(record?.id, 'missing')}${extension}`);
+  }
+
+  async _record(record) {
+    const previous = this.index.captures;
+    this.index.captures = [record, ...previous.filter(item => item.id !== record.id)].slice(0, MAX_INDEX_RECORDS);
+    await atomicJson(this.indexPath, { captures: this.index.captures });
+    const retained = new Set(this.index.captures.map(item => item.id));
+    await Promise.all(previous.filter(item => !retained.has(item.id)).map(item => rm(this.resolveFilePath(item), { force: true })));
+    return record;
+  }
+
+  async _cleanupTempFiles() {
+    // In-memory sessions cannot be resumed after a Hub restart. Remove only
+    // orphaned partials so they never become visible as completed captures.
+    const tempDir = path.join(this.root, '.tmp');
+    const entries = await readFileNames(tempDir);
+    await Promise.all(entries.filter(name => name.endsWith('.part')).map(name =>
+      rm(path.join(tempDir, name), { force: true })));
+  }
+}
+
+async function readFileNames(directory) {
+  try {
+    return await readdir(directory);
+  } catch {
+    return [];
+  }
+}

package/src/http/hub-role-guard.js

@@ -0,0 +1,8 @@
+export function roleGuardResponse(actualRole, requiredRole) {
+  return {
+    ok: false,
+    error: 'runtime-role-not-active',
+    role: actualRole,
+    requiredRole
+  };
+}