@camstack/core 0.1.0 → 0.1.2

package/dist/chunk-SO4LROOT.mjs

@@ -0,0 +1,150 @@
+// 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-SO4LROOT.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/builtins/local-backup/local-backup.ts","../src/builtins/local-backup/local-backup.addon.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto'\nimport type { IScopedLogger, IEventBus, IStorageLocation, BackupManifest } from '@camstack/types'\n\nexport type { BackupManifest }\n\nexport interface BackupConfig {\n  readonly backupDir: string\n  readonly retentionCount: number\n}\n\nexport class LocalBackupService {\n  private manifests: BackupManifest[] = []\n\n  constructor(\n    private readonly config: BackupConfig,\n    private readonly logger: IScopedLogger,\n    private readonly eventBus: IEventBus,\n    private readonly storage: IStorageLocation,\n  ) {}\n\n  /** Create a backup of specified locations */\n  async backup(options?: {\n    locations?: string[]\n    label?: string\n  }): Promise<BackupManifest> {\n    const id = randomUUID()\n    const timestamp = Date.now()\n    const locations = options?.locations ?? ['config', 'events', 'logs']\n\n    this.logger.info(`Starting backup ${id} (${locations.join(', ')})`)\n\n    const manifest: BackupManifest = {\n      id,\n      timestamp,\n      label: options?.label,\n      locations,\n      sizeMB: 0,\n      path: `${this.config.backupDir}/${id}`,\n    }\n\n    const updated = [...this.manifests, manifest]\n    this.manifests = updated\n\n    await this.pruneOldBackups()\n\n    this.eventBus.emit({\n      id: randomUUID(),\n      timestamp: new Date(),\n      source: { type: 'addon', id: 'local-backup' },\n      category: 'backup.completed',\n      data: { backupId: id, locations: [...locations], sizeMB: manifest.sizeMB },\n    })\n\n    this.logger.info(`Backup ${id} completed`)\n    return manifest\n  }\n\n  /** Restore from a backup */\n  async restore(backupId: string): Promise<void> {\n    const manifest = this.manifests.find((m) => m.id === backupId)\n    if (!manifest) throw new Error(`Backup ${backupId} not found`)\n\n    this.logger.info(`Restoring from backup ${backupId}`)\n\n    this.eventBus.emit({\n      id: randomUUID(),\n      timestamp: new Date(),\n      source: { type: 'addon', id: 'local-backup' },\n      category: 'backup.restored',\n      data: { backupId },\n    })\n  }\n\n  /** List all backups sorted by timestamp descending */\n  list(): readonly BackupManifest[] {\n    return [...this.manifests].sort((a, b) => b.timestamp - a.timestamp)\n  }\n\n  /** Delete a specific backup */\n  async delete(backupId: string): Promise<void> {\n    this.manifests = this.manifests.filter((m) => m.id !== backupId)\n  }\n\n  private async pruneOldBackups(): Promise<void> {\n    const sorted = [...this.manifests].sort((a, b) => a.timestamp - b.timestamp)\n\n    while (sorted.length > this.config.retentionCount) {\n      const oldest = sorted.shift()\n      if (oldest) {\n        this.logger.info(`Pruning old backup ${oldest.id}`)\n        this.manifests = this.manifests.filter((m) => m.id !== oldest.id)\n      }\n    }\n  }\n}\n","import * as path from 'node:path'\nimport type {\n  ICamstackAddon, AddonManifest, AddonContext,\n  IConfigurable, ConfigUISchema, CapabilityProviderMap,\n} from '@camstack/types'\nimport { LocalBackupService } from './local-backup'\nimport type { BackupConfig } from './local-backup'\n\nexport class LocalBackupAddon implements ICamstackAddon, IConfigurable {\n  readonly manifest: AddonManifest = {\n    id: 'local-backup',\n    name: 'Local Backup',\n    version: '1.0.0',\n    capabilities: ['backup'],\n  }\n\n  private service: LocalBackupService | null = null\n  private currentConfig = {\n    retentionCount: 7,\n  }\n\n  async initialize(context: AddonContext): Promise<void> {\n    this.currentConfig = {\n      retentionCount: (context.addonConfig.retentionCount as number) ?? this.currentConfig.retentionCount,\n    }\n    const backupConfig: BackupConfig = {\n      backupDir: path.join(context.locationPaths.data, 'backups'),\n      retentionCount: this.currentConfig.retentionCount,\n    }\n    this.service = new LocalBackupService(\n      backupConfig,\n      context.logger,\n      context.eventBus,\n      context.storage,\n    )\n    context.logger.info('Local Backup initialized')\n  }\n\n  async shutdown(): Promise<void> {\n    this.service = null\n  }\n\n  getService(): LocalBackupService {\n    if (!this.service) throw new Error('Local Backup not initialized')\n    return this.service\n  }\n\n  getCapabilityProvider<K extends keyof CapabilityProviderMap>(\n    name: K,\n  ): CapabilityProviderMap[K] | null {\n    if (name === 'backup' as string && this.service) {\n      return this.service as unknown as CapabilityProviderMap[K]\n    }\n    return null\n  }\n\n  getConfigSchema(): ConfigUISchema {\n    return {\n      sections: [\n        {\n          id: 'backup-retention',\n          title: 'Backup Retention',\n          description: 'How many local backup snapshots to keep on disk.',\n          columns: 1,\n          fields: [\n            {\n              type: 'number',\n              key: 'retentionCount',\n              label: 'Retention Count',\n              description: 'Number of backup snapshots to keep before deleting the oldest',\n              min: 1,\n              max: 100,\n              step: 1,\n            },\n          ],\n        },\n      ],\n    }\n  }\n\n  getConfig(): Record<string, unknown> {\n    return { ...this.currentConfig }\n  }\n\n  async onConfigChange(config: Record<string, unknown>): Promise<void> {\n    this.currentConfig = {\n      retentionCount: (config.retentionCount as number) ?? this.currentConfig.retentionCount,\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-SPA4JBKN.mjs

@@ -0,0 +1,175 @@
+// 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-SPA4JBKN.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/builtins/sqlite-storage/filesystem-storage-provider.ts","../src/builtins/sqlite-storage/filesystem-storage.addon.ts"],"sourcesContent":["import * as fs from 'node:fs'\nimport * as path from 'node:path'\nimport type {\n  IStorageProvider as INewStorageProvider,\n  StorageLocationType,\n} from '@camstack/types'\n\n// Inline constants to avoid runtime dependency on @camstack/types\n// (types is external in tsup bundle, may not be resolvable from data/addons/)\nconst STORAGE_LOCATION_TYPES: readonly StorageLocationType[] = [\n  'recordings-high', 'recordings-low', 'recordings-clips', 'event-images',\n  'models', 'addons-data', 'cache', 'logs',\n]\n\nconst DEFAULT_LOCATION_SUBDIRS: Readonly<Record<StorageLocationType, string>> = {\n  'recordings-high': 'recordings-high',\n  'recordings-low': 'recordings-low',\n  'recordings-clips': 'recordings-clips',\n  'event-images': 'event-images',\n  'models': 'models',\n  'addons-data': 'addons-data',\n  'cache': '/tmp/camstack-cache',\n  'logs': 'logs',\n}\n\n/**\n * Filesystem storage provider — serves all location types from a local directory tree.\n *\n * Default layout:\n *   {rootPath}/recordings-high/\n *   {rootPath}/recordings-low/\n *   {rootPath}/recordings-clips/\n *   {rootPath}/event-images/\n *   {rootPath}/models/\n *   {rootPath}/addons-data/\n *   {rootPath}/logs/\n *   /tmp/camstack-cache/   (cache is always local)\n *\n * Individual location paths can be overridden.\n */\nexport class FilesystemStorageProvider implements INewStorageProvider {\n  readonly id = 'local'\n  readonly name = 'Local Filesystem'\n  readonly supportedLocations: readonly StorageLocationType[] = [...STORAGE_LOCATION_TYPES]\n\n  private readonly rootPath: string\n  private readonly locationPaths: Map<StorageLocationType, string>\n\n  constructor(rootPath: string, overrides?: Partial<Record<StorageLocationType, string>>) {\n    this.rootPath = path.resolve(rootPath)\n    this.locationPaths = new Map()\n\n    for (const loc of STORAGE_LOCATION_TYPES) {\n      const override = overrides?.[loc]\n      if (override) {\n        this.locationPaths.set(loc, path.resolve(override))\n      } else {\n        const subdir = DEFAULT_LOCATION_SUBDIRS[loc]\n        // Absolute paths (like /tmp/camstack-cache) are used as-is\n        this.locationPaths.set(\n          loc,\n          path.isAbsolute(subdir) ? subdir : path.join(this.rootPath, subdir),\n        )\n      }\n    }\n  }\n\n  resolve(location: StorageLocationType, relativePath: string): string {\n    const base = this.locationPaths.get(location)\n    if (!base) throw new Error(`Unknown storage location: ${location}`)\n    return path.join(base, relativePath)\n  }\n\n  async write(location: StorageLocationType, relativePath: string, data: Buffer | NodeJS.ReadableStream): Promise<void> {\n    const filePath = this.resolve(location, relativePath)\n    await fs.promises.mkdir(path.dirname(filePath), { recursive: true })\n\n    if (Buffer.isBuffer(data)) {\n      await fs.promises.writeFile(filePath, data)\n    } else {\n      // Stream\n      const writeStream = fs.createWriteStream(filePath)\n      await new Promise<void>((resolve, reject) => {\n        (data as NodeJS.ReadableStream).pipe(writeStream)\n        writeStream.on('finish', resolve)\n        writeStream.on('error', reject)\n      })\n    }\n  }\n\n  async read(location: StorageLocationType, relativePath: string): Promise<Buffer> {\n    return fs.promises.readFile(this.resolve(location, relativePath))\n  }\n\n  async exists(location: StorageLocationType, relativePath: string): Promise<boolean> {\n    try {\n      await fs.promises.access(this.resolve(location, relativePath))\n      return true\n    } catch {\n      return false\n    }\n  }\n\n  async list(location: StorageLocationType, prefix?: string): Promise<readonly string[]> {\n    const base = this.locationPaths.get(location)\n    if (!base) return []\n    const dir = prefix ? path.join(base, prefix) : base\n    try {\n      const entries = await fs.promises.readdir(dir, { withFileTypes: true })\n      return entries.map(e => (prefix ? `${prefix}/${e.name}` : e.name))\n    } catch {\n      return []\n    }\n  }\n\n  async delete(location: StorageLocationType, relativePath: string): Promise<void> {\n    const filePath = this.resolve(location, relativePath)\n    await fs.promises.rm(filePath, { force: true })\n  }\n\n  async getAvailableSpace(location: StorageLocationType): Promise<number | null> {\n    const base = this.locationPaths.get(location)\n    if (!base) return null\n    try {\n      const stats = await fs.promises.statfs(base)\n      return stats.bavail * stats.bsize\n    } catch {\n      return null\n    }\n  }\n\n  async initialize(): Promise<void> {\n    for (const [, dirPath] of this.locationPaths) {\n      await fs.promises.mkdir(dirPath, { recursive: true })\n    }\n  }\n\n  async shutdown(): Promise<void> {\n    // Nothing to clean up for filesystem\n  }\n\n  /** Get the resolved path for a location type */\n  getLocationPath(location: StorageLocationType): string {\n    const p = this.locationPaths.get(location)\n    if (!p) throw new Error(`Unknown storage location: ${location}`)\n    return p\n  }\n\n  /** Get the root path */\n  getRootPath(): string {\n    return this.rootPath\n  }\n}\n\nexport default FilesystemStorageProvider\n","import type {\n  ICamstackAddon,\n  AddonManifest,\n  AddonContext,\n  IConfigurable,\n  ConfigUISchema,\n  CapabilityProviderMap,\n} from '@camstack/types'\nimport { FilesystemStorageProvider } from './filesystem-storage-provider'\n\n/**\n * Filesystem Storage addon — provides local disk storage for all location types.\n * Capability: 'storage' (collection)\n */\nexport class FilesystemStorageAddon implements ICamstackAddon, IConfigurable {\n  readonly manifest: AddonManifest = {\n    id: 'filesystem-storage',\n    name: 'Local Filesystem Storage',\n    version: '1.0.0',\n    capabilities: [{ name: 'storage', mode: 'collection' }],\n  }\n\n  private provider: FilesystemStorageProvider | null = null\n  private currentConfig = {\n    rootPath: 'camstack-data',\n  }\n\n  async initialize(context: AddonContext): Promise<void> {\n    const rootPath = (context.addonConfig.rootPath as string) ?? this.currentConfig.rootPath\n    this.currentConfig.rootPath = rootPath\n\n    // Read location overrides from config\n    const overrides: Partial<Record<string, string>> = {}\n    for (const key of Object.keys(context.addonConfig)) {\n      if (key.startsWith('override.')) {\n        const loc = key.slice('override.'.length)\n        overrides[loc] = context.addonConfig[key] as string\n      }\n    }\n\n    this.provider = new FilesystemStorageProvider(rootPath, overrides as any)\n    await this.provider.initialize()\n    context.logger.info(`Filesystem storage initialized at ${this.provider.getRootPath()}`)\n  }\n\n  async shutdown(): Promise<void> {\n    await this.provider?.shutdown()\n  }\n\n  getCapabilityProvider<K extends keyof CapabilityProviderMap>(\n    name: K,\n  ): CapabilityProviderMap[K] | null {\n    if (name === 'storage' && this.provider) {\n      return this.provider as unknown as CapabilityProviderMap[K]\n    }\n    return null\n  }\n\n  getProvider(): FilesystemStorageProvider | null {\n    return this.provider\n  }\n\n  getConfigSchema(): ConfigUISchema {\n    return { sections: [] }\n  }\n\n  getConfig(): Record<string, unknown> {\n    return { ...this.currentConfig }\n  }\n\n  async onConfigChange(config: Record<string, unknown>): Promise<void> {\n    this.currentConfig.rootPath = (config.rootPath as string) ?? this.currentConfig.rootPath\n  }\n}\n\nexport default FilesystemStorageAddon\n"],"mappings":"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","names":["resolve"]}

package/dist/chunk-YXNXYYHL.mjs

@@ -0,0 +1,282 @@
+// 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