health-sync 0.2.0

package/src/plugins/loader.js

@@ -0,0 +1,172 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { BUILTIN_PROVIDER_IDS } from '../config.js';
+import { ObjectProviderPlugin } from './base.js';
+import { builtInProviders } from '../providers/index.js';
+
+function isClassLike(fn) {
+  if (typeof fn !== 'function') {
+    return false;
+  }
+  const proto = fn.prototype;
+  return !!proto && typeof proto === 'object' && typeof proto.sync === 'function';
+}
+
+async function coercePluginObject(moduleExports, moduleSpec, configuredId = null) {
+  const candidates = [];
+  if (moduleExports?.default !== undefined) {
+    candidates.push(moduleExports.default);
+  }
+  candidates.push(moduleExports);
+  if (moduleExports?.plugin !== undefined) {
+    candidates.push(moduleExports.plugin);
+  }
+  if (moduleExports?.createPlugin !== undefined) {
+    candidates.push(moduleExports.createPlugin);
+  }
+
+  let pluginObj = null;
+  for (const candidate of candidates) {
+    if (!candidate) {
+      continue;
+    }
+    if (typeof candidate === 'object' && typeof candidate.sync === 'function') {
+      pluginObj = candidate;
+      break;
+    }
+    if (isClassLike(candidate)) {
+      pluginObj = new candidate();
+      break;
+    }
+    if (typeof candidate === 'function') {
+      const produced = candidate();
+      pluginObj = produced && typeof produced.then === 'function' ? await produced : produced;
+      if (pluginObj && typeof pluginObj.sync === 'function') {
+        break;
+      }
+      pluginObj = null;
+    }
+  }
+
+  if (!pluginObj || typeof pluginObj.sync !== 'function') {
+    throw new Error(`Module ${moduleSpec} must export a provider object with a sync() method`);
+  }
+  if (!pluginObj.id || typeof pluginObj.id !== 'string') {
+    throw new Error(`Module ${moduleSpec} provider is missing string id`);
+  }
+  if (configuredId && configuredId !== pluginObj.id) {
+    throw new Error(`Plugin id mismatch for ${moduleSpec}: expected ${configuredId} but got ${pluginObj.id}`);
+  }
+
+  return new ObjectProviderPlugin(pluginObj.id, pluginObj, 'module', moduleSpec);
+}
+
+function resolveImportSpec(moduleSpec, cwd = process.cwd()) {
+  if (moduleSpec.startsWith('.') || moduleSpec.startsWith('/')) {
+    const absolute = path.resolve(cwd, moduleSpec);
+    return pathToFileURL(absolute).href;
+  }
+  return moduleSpec;
+}
+
+async function loadFromModuleSpec(moduleSpec, configuredId = null, cwd = process.cwd()) {
+  const importSpec = resolveImportSpec(moduleSpec, cwd);
+  const mod = await import(importSpec);
+  return coercePluginObject(mod, moduleSpec, configuredId);
+}
+
+function readPackageProviderSpecs(cwd = process.cwd()) {
+  const packagePath = path.join(cwd, 'package.json');
+  if (!fs.existsSync(packagePath)) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+    const specs = parsed?.healthSyncProviders;
+    if (!specs || typeof specs !== 'object' || Array.isArray(specs)) {
+      return {};
+    }
+    return specs;
+  } catch {
+    return {};
+  }
+}
+
+export async function loadProviders(config, options = {}) {
+  const { cwd = process.cwd() } = options;
+  const providers = new Map();
+  const metadata = new Map();
+
+  for (const plugin of builtInProviders()) {
+    providers.set(plugin.id, plugin);
+    metadata.set(plugin.id, {
+      source: plugin.source,
+      moduleSpec: null,
+      builtin: true,
+    });
+  }
+
+  const packageSpecs = readPackageProviderSpecs(cwd);
+  for (const [id, moduleSpec] of Object.entries(packageSpecs)) {
+    if (!moduleSpec || typeof moduleSpec !== 'string') {
+      continue;
+    }
+    if (BUILTIN_PROVIDER_IDS.includes(id)) {
+      console.warn(`Ignoring package provider override for built-in provider ${id}`);
+      continue;
+    }
+    try {
+      const plugin = await loadFromModuleSpec(moduleSpec, id, cwd);
+      if (providers.has(plugin.id)) {
+        console.warn(`Ignoring duplicate provider id ${plugin.id} from ${moduleSpec}`);
+        continue;
+      }
+      providers.set(plugin.id, plugin);
+      metadata.set(plugin.id, {
+        source: plugin.source,
+        moduleSpec,
+        builtin: false,
+      });
+    } catch (err) {
+      console.warn(`Failed to load package provider ${id} (${moduleSpec}): ${err.message}`);
+    }
+  }
+
+  const pluginConfig = config?.plugins && typeof config.plugins === 'object' ? config.plugins : {};
+  for (const [configuredId, pluginSection] of Object.entries(pluginConfig)) {
+    if (!pluginSection || typeof pluginSection !== 'object' || Array.isArray(pluginSection)) {
+      continue;
+    }
+    const moduleSpec = typeof pluginSection.module === 'string' ? pluginSection.module.trim() : '';
+    if (!moduleSpec) {
+      continue;
+    }
+    if (BUILTIN_PROVIDER_IDS.includes(configuredId)) {
+      throw new Error(`Cannot override built-in provider \`${configuredId}\`.`);
+    }
+
+    let plugin;
+    try {
+      plugin = await loadFromModuleSpec(moduleSpec, configuredId, cwd);
+    } catch (err) {
+      throw new Error(`Failed to load configured plugin ${configuredId} (${moduleSpec}): ${err.message}`);
+    }
+
+    if (providers.has(plugin.id) && providers.get(plugin.id)?.source === 'builtin') {
+      throw new Error(`Cannot override built-in provider \`${plugin.id}\`.`);
+    }
+
+    providers.set(plugin.id, plugin);
+    metadata.set(plugin.id, {
+      source: plugin.source,
+      moduleSpec,
+      builtin: false,
+    });
+  }
+
+  return {
+    providers,
+    metadata,
+  };
+}

package/src/providers/eightsleep.js

@@ -0,0 +1,329 @@
+import {
+  parseYYYYMMDD,
+  requestJson,
+  sha256Hex,
+  utcNowIso,
+} from '../util.js';
+
+function dateToYYYYMMDD(date) {
+  const y = date.getUTCFullYear();
+  const m = String(date.getUTCMonth() + 1).padStart(2, '0');
+  const d = String(date.getUTCDate()).padStart(2, '0');
+  return `${y}-${m}-${d}`;
+}
+
+function isoToDate(value) {
+  if (!value) {
+    return null;
+  }
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+
+function tokenExpiredSoon(expiresAtIso, skewSeconds = 60) {
+  if (!expiresAtIso) {
+    return true;
+  }
+  const expiryMs = Date.parse(expiresAtIso);
+  if (Number.isNaN(expiryMs)) {
+    return true;
+  }
+  return expiryMs <= (Date.now() + skewSeconds * 1000);
+}
+
+function tokenExtra(payload) {
+  const out = {};
+  for (const [key, value] of Object.entries(payload || {})) {
+    if (key === 'access_token' || key === 'expires_in') {
+      continue;
+    }
+    out[key] = value;
+  }
+  return out;
+}
+
+async function eightsleepRefreshIfNeeded(db, cfg) {
+  if (cfg.access_token) {
+    db.setOAuthToken('eightsleep', {
+      accessToken: String(cfg.access_token),
+      refreshToken: null,
+      tokenType: 'Bearer',
+      scope: null,
+      expiresAt: null,
+      extra: { method: 'static_access_token' },
+    });
+    return String(cfg.access_token);
+  }
+
+  const existing = db.getOAuthToken('eightsleep');
+  if (existing && !tokenExpiredSoon(existing.expiresAt)) {
+    return existing.accessToken;
+  }
+
+  if (!cfg.email || !cfg.password) {
+    throw new Error('Missing [eightsleep].email or [eightsleep].password, or provide [eightsleep].access_token.');
+  }
+
+  const tokenPayload = await requestJson(cfg.auth_url || 'https://auth-api.8slp.net/v1/tokens', {
+    method: 'POST',
+    json: {
+      client_id: cfg.client_id,
+      client_secret: cfg.client_secret,
+      grant_type: 'password',
+      username: cfg.email,
+      password: cfg.password,
+    },
+  });
+
+  if (!tokenPayload?.access_token) {
+    throw new Error(`Eight Sleep auth failed: ${JSON.stringify(tokenPayload)}`);
+  }
+
+  const expiresIn = Number.parseInt(String(tokenPayload.expires_in ?? 0), 10) || 0;
+  const expiresAt = expiresIn > 0 ? new Date(Date.now() + expiresIn * 1000).toISOString().replace(/\.\d{3}Z$/, 'Z') : null;
+
+  db.setOAuthToken('eightsleep', {
+    accessToken: String(tokenPayload.access_token),
+    refreshToken: null,
+    tokenType: tokenPayload.token_type || 'Bearer',
+    scope: tokenPayload.scope || null,
+    expiresAt,
+    extra: tokenExtra(tokenPayload),
+  });
+
+  return String(tokenPayload.access_token);
+}
+
+function trendsFromDate(db, cfg) {
+  const overlapDays = Math.max(0, Number.parseInt(String(cfg.overlap_days ?? 2), 10) || 0);
+  const state = db.getSyncState('eightsleep', 'trends');
+  if (!state?.watermark) {
+    return String(cfg.start_date || '2010-01-01');
+  }
+
+  const wmDate = isoToDate(state.watermark);
+  if (!wmDate) {
+    return String(cfg.start_date || '2010-01-01');
+  }
+
+  const fromDate = new Date(Date.UTC(
+    wmDate.getUTCFullYear(),
+    wmDate.getUTCMonth(),
+    wmDate.getUTCDate(),
+    0,
+    0,
+    0,
+  ));
+  fromDate.setUTCDate(fromDate.getUTCDate() - overlapDays);
+  return dateToYYYYMMDD(fromDate);
+}
+
+function collectDeviceUserIds(payload) {
+  const ids = [];
+  const root = payload?.result && typeof payload.result === 'object' ? payload.result : payload;
+  if (!root || typeof root !== 'object') {
+    return ids;
+  }
+
+  for (const key of ['leftUserId', 'rightUserId']) {
+    if (root[key] !== undefined && root[key] !== null) {
+      ids.push(String(root[key]));
+    }
+  }
+
+  const awaySides = root.awaySides;
+  if (awaySides && typeof awaySides === 'object') {
+    for (const value of Object.values(awaySides)) {
+      if (value !== undefined && value !== null && String(value).trim()) {
+        ids.push(String(value));
+      }
+    }
+  }
+
+  return ids;
+}
+
+function extractTrendEntries(payload) {
+  if (Array.isArray(payload?.result)) {
+    return payload.result;
+  }
+  if (Array.isArray(payload?.trends)) {
+    return payload.trends;
+  }
+  if (Array.isArray(payload?.days)) {
+    return payload.days;
+  }
+  return [];
+}
+
+function trendRecordId(userId, trend) {
+  if (trend?.day) {
+    return `${userId}:${String(trend.day)}`;
+  }
+  return `${userId}:${sha256Hex(JSON.stringify(trend))}`;
+}
+
+async function eightsleepAuth(db, config, helpers) {
+  const cfg = helpers.configFor('eightsleep');
+  await eightsleepRefreshIfNeeded(db, cfg);
+  console.log('Eight Sleep authorization succeeded.');
+}
+
+async function eightsleepSync(db, config, helpers) {
+  const cfg = helpers.configFor('eightsleep');
+  const accessToken = await eightsleepRefreshIfNeeded(db, cfg);
+
+  const apiBase = String(cfg.client_api_url || 'https://client-api.8slp.net/v1').replace(/\/$/, '');
+  const headers = {
+    Authorization: `Bearer ${accessToken}`,
+  };
+
+  let mePayload;
+  let meUserId = 'me';
+  let meUser = null;
+
+  await db.syncRun('eightsleep', 'users_me', async () => {
+    await db.transaction(async () => {
+      mePayload = await requestJson(`${apiBase}/users/me`, { headers });
+      meUser = mePayload?.user && typeof mePayload.user === 'object' ? mePayload.user : null;
+      meUserId = String(meUser?.id || mePayload?.id || 'me');
+      const nowIso = utcNowIso();
+      db.upsertRecord({
+        provider: 'eightsleep',
+        resource: 'users_me',
+        recordId: meUserId,
+        startTime: null,
+        endTime: null,
+        sourceUpdatedAt: nowIso,
+        payload: mePayload,
+      });
+      db.setSyncState('eightsleep', 'users_me', {
+        watermark: nowIso,
+      });
+    });
+  });
+
+  const userIds = new Set();
+  if (meUserId !== 'me') {
+    userIds.add(meUserId);
+  }
+
+  await db.syncRun('eightsleep', 'devices', async () => {
+    await db.transaction(async () => {
+      const devices = Array.isArray(meUser?.devices)
+        ? meUser.devices
+        : Array.isArray(mePayload?.devices)
+          ? mePayload.devices
+          : [];
+      const nowIso = utcNowIso();
+
+      for (const deviceEntry of devices) {
+        const deviceId = typeof deviceEntry === 'object' && deviceEntry !== null
+          ? deviceEntry.id || deviceEntry.deviceId
+          : deviceEntry;
+        if (!deviceId) {
+          continue;
+        }
+
+        const payload = await requestJson(`${apiBase}/devices/${encodeURIComponent(String(deviceId))}`, {
+          headers,
+        });
+
+        db.upsertRecord({
+          provider: 'eightsleep',
+          resource: 'devices',
+          recordId: String(deviceId),
+          startTime: null,
+          endTime: null,
+          sourceUpdatedAt: nowIso,
+          payload,
+        });
+
+        for (const uid of collectDeviceUserIds(payload)) {
+          userIds.add(uid);
+        }
+      }
+
+      db.setSyncState('eightsleep', 'devices', {
+        watermark: nowIso,
+      });
+    });
+  });
+
+  await db.syncRun('eightsleep', 'users', async () => {
+    await db.transaction(async () => {
+      const nowIso = utcNowIso();
+      for (const userId of userIds) {
+        const payload = await requestJson(`${apiBase}/users/${encodeURIComponent(String(userId))}`, {
+          headers,
+        });
+        db.upsertRecord({
+          provider: 'eightsleep',
+          resource: 'users',
+          recordId: String(userId),
+          startTime: null,
+          endTime: null,
+          sourceUpdatedAt: nowIso,
+          payload,
+        });
+      }
+
+      db.setSyncState('eightsleep', 'users', {
+        watermark: nowIso,
+      });
+    });
+  });
+
+  await db.syncRun('eightsleep', 'trends', async () => {
+    await db.transaction(async () => {
+      const timezone = String(cfg.timezone || 'UTC');
+      const fromDate = trendsFromDate(db, cfg);
+      const todayDate = dateToYYYYMMDD(new Date());
+      const nowIso = utcNowIso();
+
+      for (const userId of userIds) {
+        const payload = await requestJson(`${apiBase}/users/${encodeURIComponent(String(userId))}/trends`, {
+          headers,
+          params: {
+            tz: timezone,
+            from: fromDate,
+            to: todayDate,
+            'include-main': 'false',
+            'include-all-sessions': 'true',
+            'model-version': 'v2',
+          },
+        });
+
+        const entries = extractTrendEntries(payload);
+        for (const trend of entries) {
+          const startTime = trend?.day || trend?.presenceStart || null;
+          const sourceUpdatedAt = trend?.updatedAt || trend?.presenceStart || startTime;
+          db.upsertRecord({
+            provider: 'eightsleep',
+            resource: 'trends',
+            recordId: trendRecordId(String(userId), trend),
+            startTime,
+            endTime: trend?.presenceEnd || null,
+            sourceUpdatedAt,
+            payload: trend,
+          });
+        }
+      }
+
+      db.setSyncState('eightsleep', 'trends', {
+        watermark: nowIso,
+      });
+    });
+  });
+}
+
+const eightsleepProvider = {
+  id: 'eightsleep',
+  source: 'builtin',
+  description: 'Eight Sleep user/device and trend data sync',
+  supportsAuth: true,
+  auth: eightsleepAuth,
+  sync: eightsleepSync,
+};
+
+export default eightsleepProvider;