claude-code-session-manager 0.81.0 → 0.83.0

package/src/main/__tests__/telemetrySettings.test.cjs

@@ -0,0 +1,178 @@
+/**
+ * telemetrySettings.test.cjs — unit tests for the telemetry consent/config store.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/telemetrySettings.test.cjs
+ */
+'use strict';
+
+import { test, expect, beforeEach, afterEach } from 'vitest';
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+
+const tmpDirs = [];
+let originalHome;
+
+beforeEach(() => {
+  originalHome = process.env.HOME;
+});
+
+afterEach(async () => {
+  if (originalHome !== undefined) process.env.HOME = originalHome;
+  delete process.env.SM_TELEMETRY;
+  delete process.env.SM_TELEMETRY_ENDPOINT;
+  while (tmpDirs.length) {
+    const d = tmpDirs.pop();
+    await fsp.rm(d, { recursive: true, force: true });
+  }
+});
+
+async function freshModule(home) {
+  process.env.HOME = home;
+  const modPath = require.resolve('../lib/telemetrySettings.cjs');
+  delete require.cache[modPath];
+  delete require.cache[require.resolve('../config.cjs')];
+  return require('../lib/telemetrySettings.cjs');
+}
+
+async function mkHome() {
+  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-telemetry-home-'));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+test('DEFAULTS carries no identity-shaped key', async () => {
+  const home = await mkHome();
+  const telemetrySettings = await freshModule(home);
+  const keys = Object.keys(telemetrySettings.DEFAULTS);
+  const identityLike = keys.filter((k) => /email|user|name|host|account/i.test(k));
+  expect(identityLike).toEqual([]);
+});
+
+test('isValid rejects a config carrying an unknown extra identity-shaped key', async () => {
+  const home = await mkHome();
+  const telemetrySettings = await freshModule(home);
+  const base = { ...telemetrySettings.DEFAULTS, installId: 'abc' };
+  expect(telemetrySettings.isValid(base)).toBe(true);
+  const withExtra = { ...base, identifyEmail: 'someone@example.com' };
+  expect(telemetrySettings.isValid(withExtra)).toBe(false);
+});
+
+test('load() mints installId once via crypto.randomUUID and persists it', async () => {
+  const home = await mkHome();
+  const telemetrySettings = await freshModule(home);
+
+  const first = await telemetrySettings.load();
+  expect(typeof first.installId).toBe('string');
+  expect(first.installId.length).toBeGreaterThan(0);
+
+  const second = await telemetrySettings.load();
+  expect(second.installId).toBe(first.installId);
+
+  const raw = JSON.parse(fs.readFileSync(telemetrySettings.storePath(), 'utf8'));
+  expect(raw.installId).toBe(first.installId);
+
+  const freshRead = await freshModule(home);
+  const third = await freshRead.load();
+  expect(third.installId).toBe(first.installId);
+});
+
+test('isEnabled: hard kill switch SM_TELEMETRY=0 overrides persisted enabled:true', async () => {
+  const home = await mkHome();
+  const telemetrySettings = await freshModule(home);
+  const cfg = { ...telemetrySettings.DEFAULTS, installId: 'x', enabled: true };
+  process.env.SM_TELEMETRY = '0';
+  expect(telemetrySettings.isEnabled(cfg)).toBe(false);
+});
+
+test('isEnabled: returns false when persisted enabled is false', async () => {
+  const home = await mkHome();
+  const telemetrySettings = await freshModule(home);
+  const cfg = { ...telemetrySettings.DEFAULTS, installId: 'x', enabled: false };
+  expect(telemetrySettings.isEnabled(cfg)).toBe(false);
+});
+
+test('isEnabled: returns true when persisted enabled is true and no kill switch', async () => {
+  const home = await mkHome();
+  const telemetrySettings = await freshModule(home);
+  const cfg = { ...telemetrySettings.DEFAULTS, installId: 'x', enabled: true };
+  expect(telemetrySettings.isEnabled(cfg)).toBe(true);
+});
+
+test('resolveEndpoint prefers SM_TELEMETRY_ENDPOINT over persisted endpoint', async () => {
+  const home = await mkHome();
+  const telemetrySettings = await freshModule(home);
+  const cfg = { ...telemetrySettings.DEFAULTS, installId: 'x', endpoint: 'https://persisted.example' };
+  process.env.SM_TELEMETRY_ENDPOINT = 'https://env-override.example';
+  expect(telemetrySettings.resolveEndpoint(cfg)).toBe('https://env-override.example');
+});
+
+test('resolveEndpoint falls back to persisted endpoint when no env override', async () => {
+  const home = await mkHome();
+  const telemetrySettings = await freshModule(home);
+  const cfg = { ...telemetrySettings.DEFAULTS, installId: 'x', endpoint: 'https://persisted.example' };
+  expect(telemetrySettings.resolveEndpoint(cfg)).toBe('https://persisted.example');
+});
+
+test('isDailyFlushDue: true when lastDailyFlushAt is null', async () => {
+  const home = await mkHome();
+  const telemetrySettings = await freshModule(home);
+  const cfg = { ...telemetrySettings.DEFAULTS, installId: 'x', lastDailyFlushAt: null };
+  expect(telemetrySettings.isDailyFlushDue(cfg, Date.now())).toBe(true);
+});
+
+test('isDailyFlushDue: false when lastDailyFlushAt is 23h before now', async () => {
+  const home = await mkHome();
+  const telemetrySettings = await freshModule(home);
+  const now = Date.now();
+  const cfg = { ...telemetrySettings.DEFAULTS, installId: 'x', lastDailyFlushAt: new Date(now - 23 * 60 * 60 * 1000).toISOString() };
+  expect(telemetrySettings.isDailyFlushDue(cfg, now)).toBe(false);
+});
+
+test('isDailyFlushDue: true when lastDailyFlushAt is 25h before now', async () => {
+  const home = await mkHome();
+  const telemetrySettings = await freshModule(home);
+  const now = Date.now();
+  const cfg = { ...telemetrySettings.DEFAULTS, installId: 'x', lastDailyFlushAt: new Date(now - 25 * 60 * 60 * 1000).toISOString() };
+  expect(telemetrySettings.isDailyFlushDue(cfg, now)).toBe(true);
+});
+
+test('isMachineReportDue: true when app version changed', async () => {
+  const home = await mkHome();
+  const telemetrySettings = await freshModule(home);
+  const now = Date.now();
+  const cfg = {
+    ...telemetrySettings.DEFAULTS,
+    installId: 'x',
+    lastMachineReportVersion: '0.80.0',
+    lastMachineReportAt: new Date(now).toISOString(),
+  };
+  expect(telemetrySettings.isMachineReportDue(cfg, { now, appVersion: '0.81.0' })).toBe(true);
+});
+
+test('isMachineReportDue: true when lastMachineReportAt is null (same version)', async () => {
+  const home = await mkHome();
+  const telemetrySettings = await freshModule(home);
+  const now = Date.now();
+  const cfg = { ...telemetrySettings.DEFAULTS, installId: 'x', lastMachineReportVersion: '0.81.0', lastMachineReportAt: null };
+  expect(telemetrySettings.isMachineReportDue(cfg, { now, appVersion: '0.81.0' })).toBe(true);
+});
+
+test('isMachineReportDue: true when lastMachineReportAt is more than 30 days before now (same version)', async () => {
+  const home = await mkHome();
+  const telemetrySettings = await freshModule(home);
+  const now = Date.now();
+  const thirtyOneDaysAgo = new Date(now - 31 * 24 * 60 * 60 * 1000).toISOString();
+  const cfg = { ...telemetrySettings.DEFAULTS, installId: 'x', lastMachineReportVersion: '0.81.0', lastMachineReportAt: thirtyOneDaysAgo };
+  expect(telemetrySettings.isMachineReportDue(cfg, { now, appVersion: '0.81.0' })).toBe(true);
+});
+
+test('isMachineReportDue: false when same version and reported less than 30 days ago', async () => {
+  const home = await mkHome();
+  const telemetrySettings = await freshModule(home);
+  const now = Date.now();
+  const oneDayAgo = new Date(now - 24 * 60 * 60 * 1000).toISOString();
+  const cfg = { ...telemetrySettings.DEFAULTS, installId: 'x', lastMachineReportVersion: '0.81.0', lastMachineReportAt: oneDayAgo };
+  expect(telemetrySettings.isMachineReportDue(cfg, { now, appVersion: '0.81.0' })).toBe(false);
+});

package/src/main/lib/machineProfile.cjs

@@ -0,0 +1,144 @@
+/**
+ * machineProfile — builds the "once per machine" telemetry payload: which
+ * build (appVersion) this install id is running, plus basic hardware/OS specs.
+ *
+ * Deliberately anonymous: no hostname, no OS username, no homedir, no MAC
+ * address, no hardware serial, no absolute filesystem path, no IANA timezone
+ * name (offset only). machineDigest is a coarse hash of stable spec fields —
+ * a hardware-CLASS fingerprint, never a device id — so individual records
+ * can be joined back to a machine class without repeating the whole profile.
+ *
+ * Pure data plumbing: no network code, no call sites. Later PRDs consume it.
+ */
+'use strict';
+
+const os = require('node:os');
+const crypto = require('node:crypto');
+const path = require('node:path');
+const claudeBin = require('./claudeBin.cjs');
+
+function resolveElectronApp() {
+  try {
+    // eslint-disable-next-line global-require
+    const electron = require('electron');
+    if (electron && typeof electron === 'object' && typeof electron.app === 'object') {
+      return electron.app;
+    }
+  } catch { /* no electron runtime (plain vitest, or electron require resolved to a path string) */ }
+  return null;
+}
+
+function resolvePackageVersion() {
+  try {
+    // src/main/lib/machineProfile.cjs -> src/main/lib -> src/main -> src -> repo root
+    const pkg = require(path.join(__dirname, '..', '..', '..', 'package.json'));
+    return (pkg && typeof pkg.version === 'string') ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 'npx' when the app path lives inside an npm/npx cache dir, 'dev' when
+ * SM_DEV is set, else 'unknown'. Injectable so tests never depend on real
+ * process state.
+ */
+function resolveInstallChannel({ appPath = null, devFlag = !!process.env.SM_DEV } = {}) {
+  if (devFlag) return 'dev';
+  if (typeof appPath === 'string' && /[\\/](\.npm|_npx|npm-cache|npx-cache)[\\/]/i.test(appPath)) {
+    return 'npx';
+  }
+  return 'unknown';
+}
+
+/** sha256 of the concatenated stable spec fields, truncated to 12 hex chars. */
+function computeMachineDigest(specs) {
+  const material = [
+    specs.platform,
+    specs.osRelease,
+    specs.arch,
+    specs.cpuModel || '',
+    String(specs.cpuCount),
+    String(specs.totalMemMb),
+  ].join('|');
+  return crypto.createHash('sha256').update(material).digest('hex').slice(0, 12);
+}
+
+/** Reads basic, non-identifying specs from node:os. Null-safe when os.cpus() is empty. */
+function readSpecs(osModule) {
+  const cpus = osModule.cpus() || [];
+  const cpu0 = cpus[0] || null;
+  return {
+    platform: osModule.platform(),
+    osRelease: osModule.release(),
+    arch: osModule.arch(),
+    cpuModel: cpu0 && typeof cpu0.model === 'string' ? cpu0.model.trim() : null,
+    cpuSpeedMhz: cpu0 && typeof cpu0.speed === 'number' ? cpu0.speed : null,
+    cpuCount: cpus.length,
+    totalMemMb: Math.round(osModule.totalmem() / 1048576),
+  };
+}
+
+/**
+ * Builds the machine profile. All external dependencies are injectable so
+ * this is fully testable under plain vitest with no Electron runtime and no
+ * real Claude CLI.
+ *
+ * @param {object} [opts]
+ * @param {object} [opts.osModule] - defaults to node:os
+ * @param {function} [opts.probeClaudeVersion] - defaults to claudeBin.probeClaudeVersion; must resolve to a string or null and never block startup
+ * @param {object|null} [opts.electronApp] - override for tests; when omitted, 'electron' is required lazily
+ * @param {string} [opts.firstSeenAt] - ISO timestamp; defaults to now (callers that track a persisted first-seen value should pass it)
+ */
+async function buildMachineProfile(opts = {}) {
+  const osModule = opts.osModule || os;
+  const probeClaudeVersion = opts.probeClaudeVersion || claudeBin.probeClaudeVersion;
+  const electronApp = Object.prototype.hasOwnProperty.call(opts, 'electronApp')
+    ? opts.electronApp
+    : resolveElectronApp();
+
+  let appVersion = null;
+  let appPath = null;
+  if (electronApp) {
+    try { appVersion = electronApp.getVersion(); } catch { /* not ready / not a real app object */ }
+    try { appPath = electronApp.getAppPath(); } catch { /* not ready / not a real app object */ }
+  }
+  if (!appVersion) appVersion = resolvePackageVersion();
+
+  const specs = readSpecs(osModule);
+  const machineDigest = computeMachineDigest(specs);
+
+  let claudeCliVersion = null;
+  try {
+    claudeCliVersion = await probeClaudeVersion();
+  } catch {
+    claudeCliVersion = null;
+  }
+
+  return {
+    appVersion,
+    installChannel: resolveInstallChannel({ appPath, devFlag: !!process.env.SM_DEV }),
+    machineDigest,
+    platform: specs.platform,
+    osRelease: specs.osRelease,
+    arch: specs.arch,
+    cpuModel: specs.cpuModel,
+    cpuCount: specs.cpuCount,
+    cpuSpeedMhz: specs.cpuSpeedMhz,
+    totalMemMb: specs.totalMemMb,
+    nodeVersion: process.versions.node || null,
+    electronVersion: process.versions.electron || null,
+    chromeVersion: process.versions.chrome || null,
+    v8Version: process.versions.v8 || null,
+    claudeCliVersion,
+    locale: Intl.DateTimeFormat().resolvedOptions().locale || null,
+    timezoneOffsetMinutes: new Date().getTimezoneOffset(),
+    firstSeenAt: opts.firstSeenAt || new Date().toISOString(),
+  };
+}
+
+module.exports = {
+  buildMachineProfile,
+  computeMachineDigest,
+  resolveInstallChannel,
+};