@camstack/core 0.1.3 → 0.1.4

package/dist/chunk-SO4LROOT.mjs

@@ -1,150 +0,0 @@
-// src/builtins/local-backup/local-backup.ts
-import { randomUUID } from "crypto";
-var LocalBackupService = class {
-  constructor(config, logger, eventBus, storage) {
-    this.config = config;
-    this.logger = logger;
-    this.eventBus = eventBus;
-    this.storage = storage;
-  }
-  manifests = [];
-  /** Create a backup of specified locations */
-  async backup(options) {
-    const id = randomUUID();
-    const timestamp = Date.now();
-    const locations = options?.locations ?? ["config", "events", "logs"];
-    this.logger.info(`Starting backup ${id} (${locations.join(", ")})`);
-    const manifest = {
-      id,
-      timestamp,
-      label: options?.label,
-      locations,
-      sizeMB: 0,
-      path: `${this.config.backupDir}/${id}`
-    };
-    const updated = [...this.manifests, manifest];
-    this.manifests = updated;
-    await this.pruneOldBackups();
-    this.eventBus.emit({
-      id: randomUUID(),
-      timestamp: /* @__PURE__ */ new Date(),
-      source: { type: "addon", id: "local-backup" },
-      category: "backup.completed",
-      data: { backupId: id, locations: [...locations], sizeMB: manifest.sizeMB }
-    });
-    this.logger.info(`Backup ${id} completed`);
-    return manifest;
-  }
-  /** Restore from a backup */
-  async restore(backupId) {
-    const manifest = this.manifests.find((m) => m.id === backupId);
-    if (!manifest) throw new Error(`Backup ${backupId} not found`);
-    this.logger.info(`Restoring from backup ${backupId}`);
-    this.eventBus.emit({
-      id: randomUUID(),
-      timestamp: /* @__PURE__ */ new Date(),
-      source: { type: "addon", id: "local-backup" },
-      category: "backup.restored",
-      data: { backupId }
-    });
-  }
-  /** List all backups sorted by timestamp descending */
-  list() {
-    return [...this.manifests].sort((a, b) => b.timestamp - a.timestamp);
-  }
-  /** Delete a specific backup */
-  async delete(backupId) {
-    this.manifests = this.manifests.filter((m) => m.id !== backupId);
-  }
-  async pruneOldBackups() {
-    const sorted = [...this.manifests].sort((a, b) => a.timestamp - b.timestamp);
-    while (sorted.length > this.config.retentionCount) {
-      const oldest = sorted.shift();
-      if (oldest) {
-        this.logger.info(`Pruning old backup ${oldest.id}`);
-        this.manifests = this.manifests.filter((m) => m.id !== oldest.id);
-      }
-    }
-  }
-};
-
-// src/builtins/local-backup/local-backup.addon.ts
-import * as path from "path";
-var LocalBackupAddon = class {
-  manifest = {
-    id: "local-backup",
-    name: "Local Backup",
-    version: "1.0.0",
-    capabilities: ["backup"]
-  };
-  service = null;
-  currentConfig = {
-    retentionCount: 7
-  };
-  async initialize(context) {
-    this.currentConfig = {
-      retentionCount: context.addonConfig.retentionCount ?? this.currentConfig.retentionCount
-    };
-    const backupConfig = {
-      backupDir: path.join(context.locationPaths.data, "backups"),
-      retentionCount: this.currentConfig.retentionCount
-    };
-    this.service = new LocalBackupService(
-      backupConfig,
-      context.logger,
-      context.eventBus,
-      context.storage
-    );
-    context.logger.info("Local Backup initialized");
-  }
-  async shutdown() {
-    this.service = null;
-  }
-  getService() {
-    if (!this.service) throw new Error("Local Backup not initialized");
-    return this.service;
-  }
-  getCapabilityProvider(name) {
-    if (name === "backup" && this.service) {
-      return this.service;
-    }
-    return null;
-  }
-  getConfigSchema() {
-    return {
-      sections: [
-        {
-          id: "backup-retention",
-          title: "Backup Retention",
-          description: "How many local backup snapshots to keep on disk.",
-          columns: 1,
-          fields: [
-            {
-              type: "number",
-              key: "retentionCount",
-              label: "Retention Count",
-              description: "Number of backup snapshots to keep before deleting the oldest",
-              min: 1,
-              max: 100,
-              step: 1
-            }
-          ]
-        }
-      ]
-    };
-  }
-  getConfig() {
-    return { ...this.currentConfig };
-  }
-  async onConfigChange(config) {
-    this.currentConfig = {
-      retentionCount: config.retentionCount ?? this.currentConfig.retentionCount
-    };
-  }
-};
-
-export {
-  LocalBackupService,
-  LocalBackupAddon
-};
-//# sourceMappingURL=chunk-SO4LROOT.mjs.map

package/dist/chunk-SPA4JBKN.mjs

@@ -1,175 +0,0 @@
-// src/builtins/sqlite-storage/filesystem-storage-provider.ts
-import * as fs from "fs";
-import * as path from "path";
-var STORAGE_LOCATION_TYPES = [
-  "recordings-high",
-  "recordings-low",
-  "recordings-clips",
-  "event-images",
-  "models",
-  "addons-data",
-  "cache",
-  "logs"
-];
-var DEFAULT_LOCATION_SUBDIRS = {
-  "recordings-high": "recordings-high",
-  "recordings-low": "recordings-low",
-  "recordings-clips": "recordings-clips",
-  "event-images": "event-images",
-  "models": "models",
-  "addons-data": "addons-data",
-  "cache": "/tmp/camstack-cache",
-  "logs": "logs"
-};
-var FilesystemStorageProvider = class {
-  id = "local";
-  name = "Local Filesystem";
-  supportedLocations = [...STORAGE_LOCATION_TYPES];
-  rootPath;
-  locationPaths;
-  constructor(rootPath, overrides) {
-    this.rootPath = path.resolve(rootPath);
-    this.locationPaths = /* @__PURE__ */ new Map();
-    for (const loc of STORAGE_LOCATION_TYPES) {
-      const override = overrides?.[loc];
-      if (override) {
-        this.locationPaths.set(loc, path.resolve(override));
-      } else {
-        const subdir = DEFAULT_LOCATION_SUBDIRS[loc];
-        this.locationPaths.set(
-          loc,
-          path.isAbsolute(subdir) ? subdir : path.join(this.rootPath, subdir)
-        );
-      }
-    }
-  }
-  resolve(location, relativePath) {
-    const base = this.locationPaths.get(location);
-    if (!base) throw new Error(`Unknown storage location: ${location}`);
-    return path.join(base, relativePath);
-  }
-  async write(location, relativePath, data) {
-    const filePath = this.resolve(location, relativePath);
-    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
-    if (Buffer.isBuffer(data)) {
-      await fs.promises.writeFile(filePath, data);
-    } else {
-      const writeStream = fs.createWriteStream(filePath);
-      await new Promise((resolve2, reject) => {
-        data.pipe(writeStream);
-        writeStream.on("finish", resolve2);
-        writeStream.on("error", reject);
-      });
-    }
-  }
-  async read(location, relativePath) {
-    return fs.promises.readFile(this.resolve(location, relativePath));
-  }
-  async exists(location, relativePath) {
-    try {
-      await fs.promises.access(this.resolve(location, relativePath));
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async list(location, prefix) {
-    const base = this.locationPaths.get(location);
-    if (!base) return [];
-    const dir = prefix ? path.join(base, prefix) : base;
-    try {
-      const entries = await fs.promises.readdir(dir, { withFileTypes: true });
-      return entries.map((e) => prefix ? `${prefix}/${e.name}` : e.name);
-    } catch {
-      return [];
-    }
-  }
-  async delete(location, relativePath) {
-    const filePath = this.resolve(location, relativePath);
-    await fs.promises.rm(filePath, { force: true });
-  }
-  async getAvailableSpace(location) {
-    const base = this.locationPaths.get(location);
-    if (!base) return null;
-    try {
-      const stats = await fs.promises.statfs(base);
-      return stats.bavail * stats.bsize;
-    } catch {
-      return null;
-    }
-  }
-  async initialize() {
-    for (const [, dirPath] of this.locationPaths) {
-      await fs.promises.mkdir(dirPath, { recursive: true });
-    }
-  }
-  async shutdown() {
-  }
-  /** Get the resolved path for a location type */
-  getLocationPath(location) {
-    const p = this.locationPaths.get(location);
-    if (!p) throw new Error(`Unknown storage location: ${location}`);
-    return p;
-  }
-  /** Get the root path */
-  getRootPath() {
-    return this.rootPath;
-  }
-};
-
-// src/builtins/sqlite-storage/filesystem-storage.addon.ts
-var FilesystemStorageAddon = class {
-  manifest = {
-    id: "filesystem-storage",
-    name: "Local Filesystem Storage",
-    version: "1.0.0",
-    capabilities: [{ name: "storage", mode: "collection" }]
-  };
-  provider = null;
-  currentConfig = {
-    rootPath: "camstack-data"
-  };
-  async initialize(context) {
-    const rootPath = context.addonConfig.rootPath ?? this.currentConfig.rootPath;
-    this.currentConfig.rootPath = rootPath;
-    const overrides = {};
-    for (const key of Object.keys(context.addonConfig)) {
-      if (key.startsWith("override.")) {
-        const loc = key.slice("override.".length);
-        overrides[loc] = context.addonConfig[key];
-      }
-    }
-    this.provider = new FilesystemStorageProvider(rootPath, overrides);
-    await this.provider.initialize();
-    context.logger.info(`Filesystem storage initialized at ${this.provider.getRootPath()}`);
-  }
-  async shutdown() {
-    await this.provider?.shutdown();
-  }
-  getCapabilityProvider(name) {
-    if (name === "storage" && this.provider) {
-      return this.provider;
-    }
-    return null;
-  }
-  getProvider() {
-    return this.provider;
-  }
-  getConfigSchema() {
-    return { sections: [] };
-  }
-  getConfig() {
-    return { ...this.currentConfig };
-  }
-  async onConfigChange(config) {
-    this.currentConfig.rootPath = config.rootPath ?? this.currentConfig.rootPath;
-  }
-};
-var filesystem_storage_addon_default = FilesystemStorageAddon;
-
-export {
-  FilesystemStorageProvider,
-  FilesystemStorageAddon,
-  filesystem_storage_addon_default
-};
-//# sourceMappingURL=chunk-SPA4JBKN.mjs.map

package/dist/chunk-YXNXYYHL.mjs

@@ -1,282 +0,0 @@
-// src/builtins/sqlite-storage/sqlite-settings-backend.ts
-import Database from "better-sqlite3";
-import { randomUUID } from "crypto";
-var SqliteSettingsBackend = class {
-  constructor(dbPath, runtimeDefaults) {
-    this.dbPath = dbPath;
-    this.runtimeDefaults = runtimeDefaults ?? {};
-  }
-  db = null;
-  ensuredTables = /* @__PURE__ */ new Set();
-  runtimeDefaults;
-  async initialize() {
-    const dir = this.dbPath.substring(0, this.dbPath.lastIndexOf("/"));
-    if (dir) {
-      const fs = await import("fs");
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    this.db = new Database(this.dbPath);
-    this.db.pragma("journal_mode = WAL");
-    this.db.pragma("foreign_keys = ON");
-    const isEmpty = await this.isEmpty("system-settings");
-    if (isEmpty) {
-      await this.seedDefaults();
-    }
-  }
-  async shutdown() {
-    this.db?.close();
-    this.db = null;
-  }
-  // ---------------------------------------------------------------------------
-  // ISettingsBackend implementation
-  // ---------------------------------------------------------------------------
-  async get(collection, key) {
-    this.ensureTable(collection);
-    const row = this.getDb().prepare(`SELECT data FROM "${collection}" WHERE id = ?`).get(key);
-    if (!row) return void 0;
-    return JSON.parse(row.data);
-  }
-  async set(collection, key, value) {
-    this.ensureTable(collection);
-    this.getDb().prepare(`INSERT INTO "${collection}" (id, data) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data`).run(key, JSON.stringify(value));
-  }
-  async query(collection, filter) {
-    this.ensureTable(collection);
-    let sql = `SELECT id, data FROM "${collection}"`;
-    const params = [];
-    const whereClauses = [];
-    if (filter?.where) {
-      for (const [field, value] of Object.entries(filter.where)) {
-        if (field === "id") {
-          whereClauses.push("id = ?");
-          params.push(value);
-        } else {
-          whereClauses.push(`json_extract(data, '$.${field}') = ?`);
-          params.push(typeof value === "object" ? JSON.stringify(value) : value);
-        }
-      }
-    }
-    if (filter?.whereIn) {
-      for (const [field, values] of Object.entries(filter.whereIn)) {
-        const placeholders = values.map(() => "?").join(", ");
-        if (field === "id") {
-          whereClauses.push(`id IN (${placeholders})`);
-        } else {
-          whereClauses.push(`json_extract(data, '$.${field}') IN (${placeholders})`);
-        }
-        params.push(...values);
-      }
-    }
-    if (filter?.whereBetween) {
-      for (const [field, [low, high]] of Object.entries(filter.whereBetween)) {
-        if (field === "id") {
-          whereClauses.push("id BETWEEN ? AND ?");
-        } else {
-          whereClauses.push(`json_extract(data, '$.${field}') BETWEEN ? AND ?`);
-        }
-        params.push(low, high);
-      }
-    }
-    if (whereClauses.length > 0) {
-      sql += ` WHERE ${whereClauses.join(" AND ")}`;
-    }
-    if (filter?.orderBy) {
-      const dir = filter.orderBy.direction === "desc" ? "DESC" : "ASC";
-      if (filter.orderBy.field === "id") {
-        sql += ` ORDER BY id ${dir}`;
-      } else {
-        sql += ` ORDER BY json_extract(data, '$.${filter.orderBy.field}') ${dir}`;
-      }
-    }
-    if (filter?.limit) {
-      sql += ` LIMIT ?`;
-      params.push(filter.limit);
-    }
-    if (filter?.offset) {
-      sql += ` OFFSET ?`;
-      params.push(filter.offset);
-    }
-    const rows = this.getDb().prepare(sql).all(...params);
-    return rows.map((row) => ({
-      id: row.id,
-      data: JSON.parse(row.data)
-    }));
-  }
-  async insert(collection, record) {
-    this.ensureTable(collection);
-    const id = record.id || randomUUID();
-    this.getDb().prepare(`INSERT INTO "${collection}" (id, data) VALUES (?, ?)`).run(id, JSON.stringify(record.data));
-  }
-  async update(collection, id, data) {
-    this.ensureTable(collection);
-    this.getDb().prepare(`UPDATE "${collection}" SET data = ? WHERE id = ?`).run(JSON.stringify(data), id);
-  }
-  async delete(collection, key) {
-    this.ensureTable(collection);
-    this.getDb().prepare(`DELETE FROM "${collection}" WHERE id = ?`).run(key);
-  }
-  async count(collection, filter) {
-    this.ensureTable(collection);
-    if (!filter) {
-      const row = this.getDb().prepare(`SELECT COUNT(*) AS cnt FROM "${collection}"`).get();
-      return row?.cnt ?? 0;
-    }
-    const rows = await this.query(collection, { ...filter, limit: void 0, offset: void 0 });
-    return rows.length;
-  }
-  async isEmpty(collection) {
-    this.ensureTable(collection);
-    const row = this.getDb().prepare(`SELECT COUNT(*) AS cnt FROM "${collection}"`).get();
-    return (row?.cnt ?? 0) === 0;
-  }
-  // ---------------------------------------------------------------------------
-  // Legacy SettingsStore compatibility (used by ConfigManager.setSettingsStore)
-  // ---------------------------------------------------------------------------
-  /** Get a system setting by dot-notation key */
-  getSystem(key) {
-    this.ensureTable("system-settings");
-    const row = this.getDb().prepare('SELECT data FROM "system-settings" WHERE id = ?').get(key);
-    if (!row) return void 0;
-    return JSON.parse(row.data);
-  }
-  /** Set a system setting */
-  setSystem(key, value) {
-    this.ensureTable("system-settings");
-    this.getDb().prepare('INSERT INTO "system-settings" (id, data) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data').run(key, JSON.stringify(value));
-  }
-  /** Get all system settings as flat key-value */
-  getAllSystem() {
-    this.ensureTable("system-settings");
-    const rows = this.getDb().prepare('SELECT id, data FROM "system-settings"').all();
-    return Object.fromEntries(rows.map((r) => [r.id, JSON.parse(r.data)]));
-  }
-  /** Get all settings for an addon */
-  getAllAddon(addonId) {
-    this.ensureTable("addon-settings");
-    const rows = this.getDb().prepare(`SELECT id, data FROM "addon-settings" WHERE json_extract(data, '$.addonId') = ?`).all(addonId);
-    if (rows.length === 0) return {};
-    const result = {};
-    for (const row of rows) {
-      const parsed = JSON.parse(row.data);
-      const key = row.id.startsWith(`${addonId}.`) ? row.id.slice(addonId.length + 1) : row.id;
-      result[key] = parsed.value ?? parsed;
-    }
-    return result;
-  }
-  /** Bulk-set all settings for an addon */
-  setAllAddon(addonId, config) {
-    this.ensureTable("addon-settings");
-    const db = this.getDb();
-    const deleteStmt = db.prepare(`DELETE FROM "addon-settings" WHERE id LIKE ? || '%'`);
-    const insertStmt = db.prepare('INSERT INTO "addon-settings" (id, data) VALUES (?, ?)');
-    db.transaction(() => {
-      deleteStmt.run(`${addonId}.`);
-      for (const [key, value] of Object.entries(config)) {
-        insertStmt.run(`${addonId}.${key}`, JSON.stringify({ addonId, key, value }));
-      }
-    })();
-  }
-  /** Get all settings for a provider */
-  getAllProvider(providerId) {
-    return this.getAllScoped("provider-settings", providerId);
-  }
-  /** Set a provider setting */
-  setProvider(providerId, key, value) {
-    this.setScopedKey("provider-settings", providerId, key, value);
-  }
-  /** Get all settings for a device */
-  getAllDevice(deviceId) {
-    return this.getAllScoped("device-settings", deviceId);
-  }
-  /** Set a device setting */
-  setDevice(deviceId, key, value) {
-    this.setScopedKey("device-settings", deviceId, key, value);
-  }
-  /** Seed system-settings with runtime defaults (first boot) */
-  async seedDefaults() {
-    this.ensureTable("system-settings");
-    const insert = this.getDb().prepare(
-      'INSERT OR IGNORE INTO "system-settings" (id, data) VALUES (?, ?)'
-    );
-    this.getDb().transaction(() => {
-      for (const [key, value] of Object.entries(this.runtimeDefaults)) {
-        insert.run(key, JSON.stringify(value));
-      }
-    })();
-  }
-  // ---------------------------------------------------------------------------
-  // Private helpers
-  // ---------------------------------------------------------------------------
-  getDb() {
-    if (!this.db) throw new Error("SqliteSettingsBackend not initialized \u2014 call initialize() first");
-    return this.db;
-  }
-  ensureTable(collection) {
-    if (this.ensuredTables.has(collection)) return;
-    this.getDb().exec(
-      `CREATE TABLE IF NOT EXISTS "${collection}" (id TEXT PRIMARY KEY, data TEXT NOT NULL)`
-    );
-    this.ensuredTables.add(collection);
-  }
-  getAllScoped(collection, scopeId) {
-    this.ensureTable(collection);
-    const rows = this.getDb().prepare(`SELECT id, data FROM "${collection}" WHERE id LIKE ? || '.%'`).all(scopeId);
-    const result = {};
-    for (const row of rows) {
-      const key = row.id.slice(scopeId.length + 1);
-      const parsed = JSON.parse(row.data);
-      result[key] = parsed.value ?? parsed;
-    }
-    return result;
-  }
-  setScopedKey(collection, scopeId, key, value) {
-    this.ensureTable(collection);
-    this.getDb().prepare(`INSERT INTO "${collection}" (id, data) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data`).run(`${scopeId}.${key}`, JSON.stringify({ scopeId, key, value }));
-  }
-};
-
-// src/builtins/sqlite-storage/sqlite-settings.addon.ts
-var SqliteSettingsAddon = class {
-  manifest = {
-    id: "sqlite-settings",
-    name: "SQLite Settings",
-    version: "1.0.0",
-    capabilities: [{ name: "settings-store", mode: "singleton" }]
-  };
-  backend = null;
-  async initialize(context) {
-    const dbPath = context.storageProvider ? context.storageProvider.resolve("addons-data", `${context.id.replace("addon:", "")}/camstack.db`) : context.dataDir ? `${context.dataDir}/camstack.db` : "camstack-data/addons-data/sqlite-settings/camstack.db";
-    const runtimeDefaults = context.addonConfig._runtimeDefaults ?? {};
-    this.backend = new SqliteSettingsBackend(dbPath, runtimeDefaults);
-    await this.backend.initialize();
-    context.logger.info(`SQLite settings initialized at ${dbPath}`);
-  }
-  async shutdown() {
-    await this.backend?.shutdown();
-  }
-  getBackend() {
-    return this.backend;
-  }
-  getCapabilityProvider(name) {
-    if (name === "settings-store" && this.backend) {
-      return this.backend;
-    }
-    return null;
-  }
-  getConfigSchema() {
-    return { sections: [] };
-  }
-  getConfig() {
-    return {};
-  }
-  async onConfigChange(_config) {
-  }
-};
-var sqlite_settings_addon_default = SqliteSettingsAddon;
-
-export {
-  SqliteSettingsBackend,
-  SqliteSettingsAddon,
-  sqlite_settings_addon_default
-};
-//# sourceMappingURL=chunk-YXNXYYHL.mjs.map