4runr-os 2.10.71 → 2.10.73

package/apps/gateway/src/__tests__/integration/sentinel.test.ts

@@ -242,6 +242,85 @@ describe('Sentinel Integration', () => {
       SENTINEL_SMOKE_TIMEOUT
     );
 
+    it(
+      'custom runIdleMs from POST /policies/custom is enforced (same path as OS UI apply)',
+      async () => {
+        if (!sentinelHealthy) {
+          console.log('Skipping: Sentinel is not healthy');
+          return;
+        }
+
+        const currentResponse = await authenticatedRequest('/api/sentinel/policies/current');
+        expect(currentResponse.status).toBe(200);
+        const currentData = await currentResponse.json();
+        const previousConfig = currentData.config as Record<string, unknown>;
+
+        const customIdleMs = 10_000;
+        const sleepMs = 13_000;
+
+        const customResponse = await authenticatedRequest('/api/sentinel/policies/custom', {
+          method: 'POST',
+          body: JSON.stringify({
+            ...previousConfig,
+            enabled: true,
+            runIdleMs: customIdleMs,
+          }),
+        });
+        expect(customResponse.status).toBe(200);
+        const customData = await customResponse.json();
+        expect(customData.config.runIdleMs).toBe(customIdleMs);
+
+        const createResponse = await authenticatedRequest('/api/runs', {
+          method: 'POST',
+          body: JSON.stringify({
+            name: 'Custom Idle Enforcement Smoke',
+            input: {
+              agent_id: 'test',
+              sleep_ms: sleepMs,
+            },
+          }),
+        });
+
+        expect([201, 429]).toContain(createResponse.status);
+        if (createResponse.status === 429) {
+          console.log('Rate limited, skipping custom idle enforcement smoke');
+          return;
+        }
+
+        const createData = await createResponse.json();
+        const runId = createData.run.id;
+
+        const startResponse = await authenticatedRequest(`/api/runs/${runId}/start`, {
+          method: 'POST',
+          body: JSON.stringify({ priority: 'high' }),
+        });
+        expect(startResponse.status).toBe(200);
+
+        const startedAt = Date.now();
+        const finalRun = await pollRunUntilStatus(runId, 'killed', {
+          maxWaitMs: 25_000,
+          intervalMs: 500,
+        });
+        const elapsedMs = Date.now() - startedAt;
+
+        expect(finalRun.status).toBe('killed');
+        expect(finalRun.output).toMatchObject({
+          source: 'sentinel',
+          reason: 'policy_violation:idle',
+          policy: 'idle',
+        });
+        // Killed near custom 10s threshold — not strict (15s) or typical UI 60s idle.
+        expect(elapsedMs).toBeGreaterThan(customIdleMs - 3_000);
+        expect(elapsedMs).toBeLessThan(14_000);
+
+        await authenticatedRequest('/api/sentinel/policies/custom', {
+          method: 'POST',
+          body: JSON.stringify(previousConfig),
+        });
+      },
+      SENTINEL_SMOKE_TIMEOUT
+    );
+
     it('GET /sentinel/health and /api/sentinel/policies/current respond for staging checks', async () => {
       const healthResponse = await authenticatedRequest('/sentinel/health');
       expect(healthResponse.status).toBe(200);

package/apps/gateway/src/__tests__/sentinel-config-persist-http.test.ts

@@ -1,93 +1,93 @@
-/**
- * HTTP apply → disk → simulated restart (proves route wiring, not UI-only).
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import Fastify from 'fastify';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { Sentinel } from '@4runr/sentinel';
-import {
-  getSentinelLimitsFilePath,
-  applyPersistedSentinelConfig,
-  hydrateSentinelConfigFromDisk,
-} from '../security/sentinel-config-store.js';
-
-jest.mock('../middleware/rateLimit.js', () => ({
-  writeRateLimit: async () => {},
-  readRateLimit: async () => {},
-}));
-
-jest.mock('../middleware/auth.js', () => ({
-  requireAuth: async () => {},
-}));
-
-describe('POST /api/sentinel/policies/custom persistence', () => {
-  const originalAppData = process.env['APPDATA'];
-  let tmpDir: string;
-  let app: ReturnType<typeof Fastify>;
-
-  beforeEach(async () => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), '4runr-sentinel-http-'));
-    process.env['APPDATA'] = tmpDir;
-    delete process.env['RUN_IDLE_MS'];
-    delete process.env['SENTINEL_IDLE_MS'];
-    Sentinel.resetInstance();
-
-    const { sentinelPolicyRoutes } = await import('../routes/sentinel-policies.js');
-    app = Fastify();
-    await sentinelPolicyRoutes(app);
-    await app.ready();
-  });
-
-  afterEach(async () => {
-    await app.close();
-    Sentinel.resetInstance();
-    if (originalAppData === undefined) delete process.env['APPDATA'];
-    else process.env['APPDATA'] = originalAppData;
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('writes sentinel-limits.json and reloads after simulated Gateway restart', async () => {
-    const distinctiveIdle = 77_777;
-
-    const res = await app.inject({
-      method: 'POST',
-      url: '/api/sentinel/policies/custom',
-      payload: {
-        enabled: true,
-        runMaxDurationMs: 120_000,
-        runMaxTokens: 16_000,
-        runIdleMs: distinctiveIdle,
-        loopWindow: 15,
-        loopMax: 5,
-        runMaxCost: 1.5,
-      },
-    });
-
-    expect(res.statusCode).toBe(200);
-    const body = res.json() as { success?: boolean; config?: { runIdleMs?: number } };
-    expect(body.success).toBe(true);
-    expect(body.config?.runIdleMs).toBe(distinctiveIdle);
-
-    const filePath = getSentinelLimitsFilePath();
-    expect(fs.existsSync(filePath)).toBe(true);
-    const onDisk = JSON.parse(fs.readFileSync(filePath, 'utf8')) as {
-      config: { runIdleMs: number };
-    };
-    expect(onDisk.config.runIdleMs).toBe(distinctiveIdle);
-
-    Sentinel.resetInstance();
-    const sentinel = Sentinel.getInstance();
-    expect(applyPersistedSentinelConfig(sentinel)).toBe(true);
-    expect(sentinel.getConfig().runIdleMs).toBe(distinctiveIdle);
-
-    Sentinel.resetInstance();
-    const stale = Sentinel.getInstance();
-    expect(stale.getConfig().runIdleMs).not.toBe(distinctiveIdle);
-
-    hydrateSentinelConfigFromDisk(stale);
-    expect(stale.getConfig().runIdleMs).toBe(distinctiveIdle);
-  });
-});
+/**
+ * HTTP apply → disk → simulated restart (proves route wiring, not UI-only).
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import Fastify from 'fastify';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { Sentinel } from '@4runr/sentinel';
+import {
+  getSentinelLimitsFilePath,
+  applyPersistedSentinelConfig,
+  hydrateSentinelConfigFromDisk,
+} from '../security/sentinel-config-store.js';
+
+jest.mock('../middleware/rateLimit.js', () => ({
+  writeRateLimit: async () => {},
+  readRateLimit: async () => {},
+}));
+
+jest.mock('../middleware/auth.js', () => ({
+  requireAuth: async () => {},
+}));
+
+describe('POST /api/sentinel/policies/custom persistence', () => {
+  const originalAppData = process.env['APPDATA'];
+  let tmpDir: string;
+  let app: ReturnType<typeof Fastify>;
+
+  beforeEach(async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), '4runr-sentinel-http-'));
+    process.env['APPDATA'] = tmpDir;
+    delete process.env['RUN_IDLE_MS'];
+    delete process.env['SENTINEL_IDLE_MS'];
+    Sentinel.resetInstance();
+
+    const { sentinelPolicyRoutes } = await import('../routes/sentinel-policies.js');
+    app = Fastify();
+    await sentinelPolicyRoutes(app);
+    await app.ready();
+  });
+
+  afterEach(async () => {
+    await app.close();
+    Sentinel.resetInstance();
+    if (originalAppData === undefined) delete process.env['APPDATA'];
+    else process.env['APPDATA'] = originalAppData;
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('writes sentinel-limits.json and reloads after simulated Gateway restart', async () => {
+    const distinctiveIdle = 77_777;
+
+    const res = await app.inject({
+      method: 'POST',
+      url: '/api/sentinel/policies/custom',
+      payload: {
+        enabled: true,
+        runMaxDurationMs: 120_000,
+        runMaxTokens: 16_000,
+        runIdleMs: distinctiveIdle,
+        loopWindow: 15,
+        loopMax: 5,
+        runMaxCost: 1.5,
+      },
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = res.json() as { success?: boolean; config?: { runIdleMs?: number } };
+    expect(body.success).toBe(true);
+    expect(body.config?.runIdleMs).toBe(distinctiveIdle);
+
+    const filePath = getSentinelLimitsFilePath();
+    expect(fs.existsSync(filePath)).toBe(true);
+    const onDisk = JSON.parse(fs.readFileSync(filePath, 'utf8')) as {
+      config: { runIdleMs: number };
+    };
+    expect(onDisk.config.runIdleMs).toBe(distinctiveIdle);
+
+    Sentinel.resetInstance();
+    const sentinel = Sentinel.getInstance();
+    expect(applyPersistedSentinelConfig(sentinel)).toBe(true);
+    expect(sentinel.getConfig().runIdleMs).toBe(distinctiveIdle);
+
+    Sentinel.resetInstance();
+    const stale = Sentinel.getInstance();
+    expect(stale.getConfig().runIdleMs).not.toBe(distinctiveIdle);
+
+    hydrateSentinelConfigFromDisk(stale);
+    expect(stale.getConfig().runIdleMs).toBe(distinctiveIdle);
+  });
+});

package/apps/gateway/src/__tests__/sentinel-config-store.test.ts

@@ -1,133 +1,133 @@
-/**
- * Sentinel limits disk persistence
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import {
-  getSentinelLimitsFilePath,
-  loadSentinelLimitsFromDisk,
-  saveSentinelLimitsToDisk,
-  applyPersistedSentinelConfig,
-} from '../security/sentinel-config-store.js';
-import { Sentinel, policyManager } from '@4runr/sentinel';
-import type { RunState } from '@4runr/sentinel';
-
-describe('sentinel-config-store', () => {
-  const originalAppData = process.env['APPDATA'];
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), '4runr-sentinel-'));
-    process.env['APPDATA'] = tmpDir;
-    Sentinel.resetInstance();
-  });
-
-  afterEach(() => {
-    Sentinel.resetInstance();
-    if (originalAppData === undefined) {
-      delete process.env['APPDATA'];
-    } else {
-      process.env['APPDATA'] = originalAppData;
-    }
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('round-trips config to disk', () => {
-    const config = {
-      enabled: true,
-      runMaxDurationMs: 90_000,
-      runMaxTokens: 8_000,
-      runIdleMs: 45_000,
-      loopWindow: 10,
-      loopMax: 3,
-      runMaxCost: 1.25,
-    };
-    saveSentinelLimitsToDisk(config);
-    expect(fs.existsSync(getSentinelLimitsFilePath())).toBe(true);
-    const loaded = loadSentinelLimitsFromDisk();
-    expect(loaded).toMatchObject(config);
-  });
-
-  it('applyPersistedSentinelConfig merges when env field unset', () => {
-    delete process.env['RUN_IDLE_MS'];
-    delete process.env['SENTINEL_IDLE_MS'];
-    saveSentinelLimitsToDisk({
-      enabled: true,
-      runMaxDurationMs: 60_000,
-      runMaxTokens: 16_000,
-      runIdleMs: 99_000,
-      loopWindow: 15,
-      loopMax: 5,
-      runMaxCost: 2.0,
-    });
-    const sentinel = Sentinel.getInstance();
-    applyPersistedSentinelConfig(sentinel);
-    expect(sentinel.getConfig().runIdleMs).toBe(99_000);
-  });
-
-  it('simulates Gateway restart: disk limits reload into a fresh Sentinel singleton', () => {
-    delete process.env['RUN_IDLE_MS'];
-    delete process.env['SENTINEL_IDLE_MS'];
-
-    const distinctiveIdle = 12_345;
-    saveSentinelLimitsToDisk({
-      enabled: true,
-      runMaxDurationMs: 600_000,
-      runMaxTokens: 50_000,
-      runIdleMs: distinctiveIdle,
-      loopWindow: 15,
-      loopMax: 5,
-      runMaxCost: 3.5,
-    });
-
-    Sentinel.resetInstance();
-    const sentinel = Sentinel.getInstance();
-    expect(sentinel.getConfig().runIdleMs).not.toBe(distinctiveIdle);
-
-    expect(applyPersistedSentinelConfig(sentinel)).toBe(true);
-    expect(sentinel.getConfig().runIdleMs).toBe(distinctiveIdle);
-    expect(sentinel.getConfig().runMaxCost).toBe(3.5);
-  });
-
-  it('persisted limits drive real policy evaluation (not display-only)', () => {
-    delete process.env['RUN_IDLE_MS'];
-    delete process.env['SENTINEL_IDLE_MS'];
-
-    const idleMs = 8_000;
-    saveSentinelLimitsToDisk({
-      enabled: true,
-      runMaxDurationMs: 600_000,
-      runMaxTokens: 50_000,
-      runIdleMs: idleMs,
-      loopWindow: 15,
-      loopMax: 5,
-      runMaxCost: 1.0,
-    });
-
-    Sentinel.resetInstance();
-    const sentinel = Sentinel.getInstance();
-    applyPersistedSentinelConfig(sentinel);
-
-    const runState: RunState = {
-      runId: 'run-persist-verify',
-      createdAt: Date.now(),
-      startedAt: Date.now() - 20_000,
-      lastTokenAt: Date.now() - 20_000,
-      tokenCount: 0,
-      status: 'running',
-      events: [],
-    };
-
-    const violations = policyManager.evaluatePolicies(
-      'run-persist-verify',
-      runState,
-      sentinel.getConfig()
-    );
-    const idleViolation = violations.find((v) => v.policy === 'idle');
-    expect(idleViolation).toBeDefined();
-    expect(idleViolation!.threshold).toBe(idleMs);
-  });
-});
+/**
+ * Sentinel limits disk persistence
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import {
+  getSentinelLimitsFilePath,
+  loadSentinelLimitsFromDisk,
+  saveSentinelLimitsToDisk,
+  applyPersistedSentinelConfig,
+} from '../security/sentinel-config-store.js';
+import { Sentinel, policyManager } from '@4runr/sentinel';
+import type { RunState } from '@4runr/sentinel';
+
+describe('sentinel-config-store', () => {
+  const originalAppData = process.env['APPDATA'];
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), '4runr-sentinel-'));
+    process.env['APPDATA'] = tmpDir;
+    Sentinel.resetInstance();
+  });
+
+  afterEach(() => {
+    Sentinel.resetInstance();
+    if (originalAppData === undefined) {
+      delete process.env['APPDATA'];
+    } else {
+      process.env['APPDATA'] = originalAppData;
+    }
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('round-trips config to disk', () => {
+    const config = {
+      enabled: true,
+      runMaxDurationMs: 90_000,
+      runMaxTokens: 8_000,
+      runIdleMs: 45_000,
+      loopWindow: 10,
+      loopMax: 3,
+      runMaxCost: 1.25,
+    };
+    saveSentinelLimitsToDisk(config);
+    expect(fs.existsSync(getSentinelLimitsFilePath())).toBe(true);
+    const loaded = loadSentinelLimitsFromDisk();
+    expect(loaded).toMatchObject(config);
+  });
+
+  it('applyPersistedSentinelConfig merges when env field unset', () => {
+    delete process.env['RUN_IDLE_MS'];
+    delete process.env['SENTINEL_IDLE_MS'];
+    saveSentinelLimitsToDisk({
+      enabled: true,
+      runMaxDurationMs: 60_000,
+      runMaxTokens: 16_000,
+      runIdleMs: 99_000,
+      loopWindow: 15,
+      loopMax: 5,
+      runMaxCost: 2.0,
+    });
+    const sentinel = Sentinel.getInstance();
+    applyPersistedSentinelConfig(sentinel);
+    expect(sentinel.getConfig().runIdleMs).toBe(99_000);
+  });
+
+  it('simulates Gateway restart: disk limits reload into a fresh Sentinel singleton', () => {
+    delete process.env['RUN_IDLE_MS'];
+    delete process.env['SENTINEL_IDLE_MS'];
+
+    const distinctiveIdle = 12_345;
+    saveSentinelLimitsToDisk({
+      enabled: true,
+      runMaxDurationMs: 600_000,
+      runMaxTokens: 50_000,
+      runIdleMs: distinctiveIdle,
+      loopWindow: 15,
+      loopMax: 5,
+      runMaxCost: 3.5,
+    });
+
+    Sentinel.resetInstance();
+    const sentinel = Sentinel.getInstance();
+    expect(sentinel.getConfig().runIdleMs).not.toBe(distinctiveIdle);
+
+    expect(applyPersistedSentinelConfig(sentinel)).toBe(true);
+    expect(sentinel.getConfig().runIdleMs).toBe(distinctiveIdle);
+    expect(sentinel.getConfig().runMaxCost).toBe(3.5);
+  });
+
+  it('persisted limits drive real policy evaluation (not display-only)', () => {
+    delete process.env['RUN_IDLE_MS'];
+    delete process.env['SENTINEL_IDLE_MS'];
+
+    const idleMs = 8_000;
+    saveSentinelLimitsToDisk({
+      enabled: true,
+      runMaxDurationMs: 600_000,
+      runMaxTokens: 50_000,
+      runIdleMs: idleMs,
+      loopWindow: 15,
+      loopMax: 5,
+      runMaxCost: 1.0,
+    });
+
+    Sentinel.resetInstance();
+    const sentinel = Sentinel.getInstance();
+    applyPersistedSentinelConfig(sentinel);
+
+    const runState: RunState = {
+      runId: 'run-persist-verify',
+      createdAt: Date.now(),
+      startedAt: Date.now() - 20_000,
+      lastTokenAt: Date.now() - 20_000,
+      tokenCount: 0,
+      status: 'running',
+      events: [],
+    };
+
+    const violations = policyManager.evaluatePolicies(
+      'run-persist-verify',
+      runState,
+      sentinel.getConfig()
+    );
+    const idleViolation = violations.find((v) => v.policy === 'idle');
+    expect(idleViolation).toBeDefined();
+    expect(idleViolation!.threshold).toBe(idleMs);
+  });
+});