idlewatch 0.1.0

package/test/usage-alert.test.mjs

@@ -0,0 +1,73 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { deriveUsageAlert } from '../src/usage-alert.js'
+
+test('returns critical when ingestion is unavailable', () => {
+  const result = deriveUsageAlert({ usageIngestionStatus: 'unavailable', usageActivityStatus: 'fresh' })
+  assert.deepEqual(result, { level: 'critical', reason: 'ingestion-unavailable' })
+})
+
+test('returns warning when activity is stale', () => {
+  const result = deriveUsageAlert({ usageIngestionStatus: 'ok', usageActivityStatus: 'stale' })
+  assert.deepEqual(result, { level: 'warning', reason: 'activity-stale' })
+})
+
+test('prioritizes stale-threshold warning over stale refresh-no-new-noise', () => {
+  const result = deriveUsageAlert(
+    {
+      usageIngestionStatus: 'ok',
+      usageActivityStatus: 'stale',
+      usagePastStaleThreshold: true,
+      usageRefreshAttempted: true,
+      usageRefreshRecovered: false
+    }
+  )
+  assert.deepEqual(result, { level: 'warning', reason: 'activity-past-threshold' })
+})
+
+test('keeps stale-no-new-usage notice when explicitly forced despite not being past threshold', () => {
+  const result = deriveUsageAlert({
+    usageIngestionStatus: 'ok',
+    usageActivityStatus: 'stale',
+    usageRefreshAttempted: true,
+    usageRefreshRecovered: false,
+    usagePastStaleThreshold: false
+  })
+  assert.deepEqual(result, { level: 'notice', reason: 'activity-no-new-usage' })
+})
+
+test('returns warning when past stale threshold in grace window', () => {
+  const result = deriveUsageAlert({ usageIngestionStatus: 'ok', usageActivityStatus: 'aging', usagePastStaleThreshold: true })
+  assert.deepEqual(result, { level: 'warning', reason: 'activity-past-threshold' })
+})
+
+test('returns notice when near stale', () => {
+  const result = deriveUsageAlert({ usageIngestionStatus: 'ok', usageActivityStatus: 'fresh', usageNearStale: true })
+  assert.deepEqual(result, { level: 'notice', reason: 'activity-near-stale' })
+})
+
+test('returns off when usage is disabled', () => {
+  const result = deriveUsageAlert({ usageIngestionStatus: 'disabled', usageActivityStatus: 'disabled' })
+  assert.deepEqual(result, { level: 'off', reason: 'usage-disabled' })
+})
+
+test('returns ok when usage is healthy', () => {
+  const result = deriveUsageAlert({ usageIngestionStatus: 'ok', usageActivityStatus: 'fresh', usageNearStale: false })
+  assert.deepEqual(result, { level: 'ok', reason: 'healthy' })
+})
+
+test('downgrades stale to idle notice when usage age exceeds idle threshold', () => {
+  const result = deriveUsageAlert(
+    { usageIngestionStatus: 'ok', usageActivityStatus: 'stale' },
+    { usageAgeMs: 3600000, idleAfterMs: 1800000 }
+  )
+  assert.deepEqual(result, { level: 'notice', reason: 'activity-idle' })
+})
+
+test('does not emit idle notice when ingestion is unavailable', () => {
+  const result = deriveUsageAlert(
+    { usageIngestionStatus: 'unavailable', usageActivityStatus: 'stale' },
+    { usageAgeMs: 3600000, idleAfterMs: 1800000 }
+  )
+  assert.deepEqual(result, { level: 'critical', reason: 'ingestion-unavailable' })
+})

package/test/usage-freshness.test.mjs

@@ -0,0 +1,63 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { deriveUsageFreshness } from '../src/usage-freshness.js'
+
+test('deriveUsageFreshness marks stale only when age is strictly above threshold', () => {
+  const usage = { usageTimestampMs: 1000 }
+
+  const atThreshold = deriveUsageFreshness(usage, 7000, 6000, 4500)
+  assert.equal(atThreshold.usageAgeMs, 6000)
+  assert.equal(atThreshold.isStale, false)
+  assert.equal(atThreshold.isPastStaleThreshold, false)
+  assert.equal(atThreshold.isNearStale, true)
+  assert.equal(atThreshold.freshnessState, 'aging')
+
+  const overThreshold = deriveUsageFreshness(usage, 7001, 6000, 4500)
+  assert.equal(overThreshold.usageAgeMs, 6001)
+  assert.equal(overThreshold.isStale, true)
+  assert.equal(overThreshold.isPastStaleThreshold, true)
+  assert.equal(overThreshold.freshnessState, 'stale')
+})
+
+test('deriveUsageFreshness handles invalid or future timestamps safely', () => {
+  assert.deepEqual(deriveUsageFreshness({}, 1000, 6000), {
+    usageAgeMs: null,
+    isStale: false,
+    isNearStale: false,
+    isPastStaleThreshold: false,
+    freshnessState: 'unknown'
+  })
+  assert.deepEqual(deriveUsageFreshness({ usageTimestampMs: 2000 }, 1000, 6000), {
+    usageAgeMs: null,
+    isStale: false,
+    isNearStale: false,
+    isPastStaleThreshold: false,
+    freshnessState: 'unknown'
+  })
+})
+
+test('deriveUsageFreshness disables stale classification for invalid thresholds', () => {
+  const usage = { usageTimestampMs: 1000 }
+  const result = deriveUsageFreshness(usage, 9000, 0, 5000)
+  assert.equal(result.usageAgeMs, 8000)
+  assert.equal(result.isStale, false)
+  assert.equal(result.isPastStaleThreshold, false)
+  assert.equal(result.isNearStale, true)
+  assert.equal(result.freshnessState, 'aging')
+})
+
+test('deriveUsageFreshness applies grace window before stale classification', () => {
+  const usage = { usageTimestampMs: 1000 }
+
+  const duringGrace = deriveUsageFreshness(usage, 7600, 6000, 4500, 2000)
+  assert.equal(duringGrace.usageAgeMs, 6600)
+  assert.equal(duringGrace.isPastStaleThreshold, true)
+  assert.equal(duringGrace.isStale, false)
+  assert.equal(duringGrace.freshnessState, 'aging')
+
+  const afterGrace = deriveUsageFreshness(usage, 9001, 6000, 4500, 2000)
+  assert.equal(afterGrace.usageAgeMs, 8001)
+  assert.equal(afterGrace.isPastStaleThreshold, true)
+  assert.equal(afterGrace.isStale, true)
+  assert.equal(afterGrace.freshnessState, 'stale')
+})

package/test/validate-dry-run-schema.test.mjs

@@ -0,0 +1,146 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { spawnSync } from 'node:child_process'
+import path from 'node:path'
+
+const root = path.resolve(process.cwd())
+
+function runDryRunSchemaWithCommand(commandArgs, envOverrides = {}) {
+  const result = spawnSync(process.execPath, [
+    path.join(root, 'scripts', 'validate-dry-run-schema.mjs'),
+    ...commandArgs
+  ], {
+    env: {
+      ...process.env,
+      IDLEWATCH_DRY_RUN_TIMEOUT_MS: '5000',
+      ...envOverrides
+    },
+    encoding: 'utf8'
+  })
+
+  assert.equal(result.status, 0, `dry-run schema validation failed: ${(result.stderr || result.stdout).trim()}`)
+}
+
+function runDryRunSchemaWithOpenClawMode(mode) {
+  runDryRunSchemaWithCommand([
+    process.execPath,
+    path.join(root, 'bin', 'idlewatch-agent.js'),
+    '--dry-run'
+  ], {
+    IDLEWATCH_OPENCLAW_USAGE: mode,
+    IDLEWATCH_OPENCLAW_PROBE_TIMEOUT_MS: '2500',
+    IDLEWATCH_OPENCLAW_PROBE_RETRIES: '1'
+  })
+}
+
+function runDryRunSchemaWithNoisyMultilineCommand() {
+  const commandScript = `
+const row = {
+  host: 'ci-mock-host',
+  ts: Date.now(),
+  cpuPct: null,
+  memPct: null,
+  memUsedPct: null,
+  memPressurePct: null,
+  memPressureClass: 'unavailable',
+  gpuPct: null,
+  gpuSource: 'mock',
+  gpuConfidence: 'none',
+  gpuSampleWindowMs: null,
+  tokensPerMin: null,
+  openclawModel: null,
+  openclawTotalTokens: null,
+  openclawSessionId: null,
+  openclawAgentId: null,
+  openclawUsageTs: null,
+  openclawUsageAgeMs: null,
+  source: {
+    usage: 'disabled',
+    usageIntegrationStatus: 'unavailable',
+    usageIngestionStatus: 'disabled',
+    usageFreshnessState: 'disabled',
+    usageActivityStatus: 'disabled',
+    usageAlertLevel: 'off',
+    usageAlertReason: 'usage-disabled',
+    usageNearStale: false,
+    usagePastStaleThreshold: false,
+    usageRefreshAttempted: false,
+    usageRefreshRecovered: false,
+    usageRefreshAttempts: 0,
+    usageRefreshReprobes: 1,
+    usageRefreshDelayMs: 250,
+    usageRefreshDurationMs: null,
+    usageRefreshOnNearStale: true,
+    usageIdle: false,
+    usageCommand: null,
+    usageProbeResult: 'disabled',
+    usageProbeAttempts: 0,
+    usageProbeDurationMs: null,
+    usageProbeSweeps: 0,
+    usageProbeRetries: 0,
+    usageProbeTimeoutMs: 4000,
+    usageProbeError: null,
+    usageUsedFallbackCache: false,
+    usageFallbackCacheAgeMs: null,
+    usageFallbackCacheSource: null,
+    usageStaleMsThreshold: 60000,
+    usageNearStaleMsThreshold: 51000,
+    usageStaleGraceMs: 10000,
+    usageIdleAfterMsThreshold: 21600000,
+    memPressureSource: 'mock'
+  },
+  schemaFamily: 'idlewatch.metric.v1',
+  schemaVersion: '1.0.0',
+  schemaCompat: ['idlewatch.metric.v1'],
+  fleet: {
+    host: 'ci-mock-host',
+    collectedAtMs: Date.now(),
+    resources: {
+      cpuPct: null,
+      memUsedPct: null,
+      memPressurePct: null,
+      memPressureClass: 'unavailable'
+    },
+    usage: {
+      model: null,
+      totalTokens: null,
+      tokensPerMin: null,
+      sessionId: null,
+      agentId: null,
+      usageTimestampMs: null,
+      usageAgeMs: null,
+      freshnessState: null,
+      integrationStatus: 'unavailable',
+      ingestionStatus: 'disabled',
+      activityStatus: 'disabled',
+      alertLevel: 'off'
+    },
+    provenance: {
+      collector: 'idlewatch-agent',
+      collectorVersion: null
+    }
+  }
+}
+
+console.log('\x1b[32m[init]\x1b[0m booting')
+console.log(JSON.stringify(row, null, 2))
+console.log('done')
+`
+
+  runDryRunSchemaWithCommand([
+    process.execPath,
+    '-e',
+    commandScript
+  ], {
+    IDLEWATCH_OPENCLAW_USAGE: 'off',
+    IDLEWATCH_DRY_RUN_TIMEOUT_MS: '5000'
+  })
+}
+
+test('validate dry-run schema passes with OpenClaw usage disabled', () => {
+  runDryRunSchemaWithOpenClawMode('off')
+})
+
+test('validate dry-run schema accepts noisy multiline JSON rows', () => {
+  runDryRunSchemaWithNoisyMultilineCommand()
+})