@cyanautomation/kaseki-agent 1.4.1

package/src/utils/webhook-event-builder.test.ts

@@ -0,0 +1,143 @@
+import {
+  createJobSubmittedEvent,
+  createJobStartedEvent,
+  createJobCompletedEvent,
+  createJobCancelledEvent,
+  createJobFailedEvent,
+} from './webhook-event-builder';
+import { WebhookEventType } from '../kaseki-api-types';
+
+describe('webhook-event-builder', () => {
+  describe('createJobSubmittedEvent', () => {
+    it('should create a JOB_SUBMITTED event', () => {
+      const event = createJobSubmittedEvent('job-123');
+
+      expect(event.eventType).toBe(WebhookEventType.JOB_SUBMITTED);
+      expect(event.jobId).toBe('job-123');
+      expect(event.data.status).toBe('queued');
+      expect(event.timestamp).toBeTruthy();
+    });
+  });
+
+  describe('createJobStartedEvent', () => {
+    it('should create a JOB_STARTED event', () => {
+      const event = createJobStartedEvent('job-456');
+
+      expect(event.eventType).toBe(WebhookEventType.JOB_STARTED);
+      expect(event.jobId).toBe('job-456');
+      expect(event.data.status).toBe('running');
+    });
+  });
+
+  describe('createJobCompletedEvent', () => {
+    it('should create a JOB_COMPLETED event without exit code', () => {
+      const event = createJobCompletedEvent('job-789');
+
+      expect(event.eventType).toBe(WebhookEventType.JOB_COMPLETED);
+      expect(event.jobId).toBe('job-789');
+      expect(event.data.status).toBe('completed');
+      expect((event.data as any).exitCode).toBeUndefined();
+    });
+
+    it('should include exit code when provided', () => {
+      const event = createJobCompletedEvent('job-789', 0);
+
+      expect((event.data as any).exitCode).toBe(0);
+    });
+
+    it('should not include null exit code', () => {
+      const event = createJobCompletedEvent('job-789', null);
+
+      expect((event.data as any).exitCode).toBeUndefined();
+    });
+  });
+
+  describe('createJobCancelledEvent', () => {
+    it('should create a JOB_CANCELLED event', () => {
+      const event = createJobCancelledEvent('job-111');
+
+      expect(event.eventType).toBe(WebhookEventType.JOB_CANCELLED);
+      expect(event.jobId).toBe('job-111');
+      expect(event.data.status).toBe('failed');
+      expect((event.data as any).failureClass).toBe('cancelled');
+    });
+
+    it('should include error message when provided', () => {
+      const event = createJobCancelledEvent('job-111', 'User requested cancellation');
+
+      expect((event.data as any).error).toBe('User requested cancellation');
+    });
+
+    it('should not include error when not provided', () => {
+      const event = createJobCancelledEvent('job-111');
+
+      expect((event.data as any).error).toBeUndefined();
+    });
+  });
+
+  describe('createJobFailedEvent', () => {
+    it('should create a JOB_FAILED event with all details', () => {
+      const event = createJobFailedEvent('job-222', 'validation-error', 'Validation failed', 1);
+
+      expect(event.eventType).toBe(WebhookEventType.JOB_FAILED);
+      expect(event.jobId).toBe('job-222');
+      expect(event.data.status).toBe('failed');
+      expect((event.data as any).failureClass).toBe('validation-error');
+      expect((event.data as any).error).toBe('Validation failed');
+      expect((event.data as any).exitCode).toBe(1);
+    });
+
+    it('should create a JOB_FAILED event with minimal details', () => {
+      const event = createJobFailedEvent('job-222');
+
+      expect(event.eventType).toBe(WebhookEventType.JOB_FAILED);
+      expect(event.data.status).toBe('failed');
+      expect((event.data as any).failureClass).toBeUndefined();
+      expect((event.data as any).error).toBeUndefined();
+      expect((event.data as any).exitCode).toBeUndefined();
+    });
+
+    it('should not include null exit code', () => {
+      const event = createJobFailedEvent('job-222', 'error', 'Failed', null as any);
+
+      expect((event.data as any).exitCode).toBeUndefined();
+    });
+
+    it('should not include undefined failureClass', () => {
+      const event = createJobFailedEvent('job-222', undefined, 'Error message');
+
+      expect((event.data as any).failureClass).toBeUndefined();
+      expect((event.data as any).error).toBe('Error message');
+    });
+  });
+
+  describe('Event payload structure', () => {
+    it('should have consistent timestamp format', () => {
+      const expectedTimestamp = '2026-05-06T12:34:56.789Z';
+
+      jest.useFakeTimers();
+      jest.setSystemTime(new Date(expectedTimestamp));
+
+      try {
+        const events = [
+          createJobSubmittedEvent('job-1'),
+          createJobStartedEvent('job-2'),
+          createJobCompletedEvent('job-3'),
+          createJobCancelledEvent('job-4'),
+          createJobFailedEvent('job-5'),
+        ];
+
+        for (const event of events) {
+          // Webhook timestamps are UTC ISO 8601 strings with millisecond precision.
+          expect(event.timestamp).toBe(expectedTimestamp);
+          expect(event.timestamp).toMatch(
+            /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])T([01]\d|2[0-3]):[0-5]\d:[0-5]\d\.\d{3}Z$/
+          );
+          expect(new Date(event.timestamp).toISOString()).toBe(event.timestamp);
+        }
+      } finally {
+        jest.useRealTimers();
+      }
+    });
+  });
+});

package/src/utils/webhook-event-builder.ts

@@ -0,0 +1,87 @@
+import { WebhookEventType, WebhookPayload } from '../kaseki-api-types';
+
+/**
+ * Factory functions for creating webhook event payloads.
+ * Consolidates webhook event creation logic across job-scheduler.ts.
+ */
+
+/**
+ * Create a JOB_SUBMITTED event payload.
+ */
+export function createJobSubmittedEvent(jobId: string): WebhookPayload {
+  return {
+    eventType: WebhookEventType.JOB_SUBMITTED,
+    jobId,
+    timestamp: new Date().toISOString(),
+    data: {
+      status: 'queued',
+    },
+  };
+}
+
+/**
+ * Create a JOB_STARTED event payload.
+ */
+export function createJobStartedEvent(jobId: string): WebhookPayload {
+  return {
+    eventType: WebhookEventType.JOB_STARTED,
+    jobId,
+    timestamp: new Date().toISOString(),
+    data: {
+      status: 'running',
+    },
+  };
+}
+
+/**
+ * Create a JOB_COMPLETED event payload.
+ */
+export function createJobCompletedEvent(jobId: string, exitCode?: number | null): WebhookPayload {
+  return {
+    eventType: WebhookEventType.JOB_COMPLETED,
+    jobId,
+    timestamp: new Date().toISOString(),
+    data: {
+      status: 'completed',
+      ...(exitCode !== null && exitCode !== undefined && { exitCode }),
+    },
+  };
+}
+
+/**
+ * Create a JOB_CANCELLED event payload.
+ */
+export function createJobCancelledEvent(jobId: string, error?: string): WebhookPayload {
+  return {
+    eventType: WebhookEventType.JOB_CANCELLED,
+    jobId,
+    timestamp: new Date().toISOString(),
+    data: {
+      status: 'failed',
+      failureClass: 'cancelled',
+      ...(error && { error }),
+    },
+  };
+}
+
+/**
+ * Create a JOB_FAILED event payload.
+ */
+export function createJobFailedEvent(
+  jobId: string,
+  failureClass?: string,
+  error?: string,
+  exitCode?: number
+): WebhookPayload {
+  return {
+    eventType: WebhookEventType.JOB_FAILED,
+    jobId,
+    timestamp: new Date().toISOString(),
+    data: {
+      status: 'failed',
+      ...(failureClass && { failureClass }),
+      ...(error && { error }),
+      ...(exitCode !== null && exitCode !== undefined && { exitCode }),
+    },
+  };
+}

package/src/webhook-manager.test.ts

@@ -0,0 +1,152 @@
+import * as fs from 'fs';
+import { WebhookManager } from './webhook-manager';
+import { WebhookConfig, WebhookEventType, WebhookPayload } from './kaseki-api-types';
+
+describe('WebhookManager retry attempts', () => {
+  const originalFetch = global.fetch;
+
+  afterEach(async () => {
+    global.fetch = originalFetch;
+    jest.restoreAllMocks();
+  });
+
+  const basePayload: WebhookPayload = {
+    eventType: WebhookEventType.JOB_FAILED,
+    jobId: 'job-123',
+    timestamp: new Date().toISOString(),
+    data: { status: 'failed', error: 'boom' },
+  };
+
+  const createConfig = (maxAttempts: number): WebhookConfig => ({
+    url: 'https://example.com/webhook',
+    retryPolicy: {
+      maxAttempts,
+      initialDelayMs: 100,
+      maxDelayMs: 1000,
+    },
+  });
+
+  test.each([
+    { maxAttempts: 1, expectedSends: 1 },
+    { maxAttempts: 2, expectedSends: 2 },
+  ])('sends exactly $expectedSends time(s) when maxAttempts=$maxAttempts', async ({ maxAttempts, expectedSends }) => {
+    const resultsDir = fs.mkdtempSync('/tmp/kaseki-webhook-manager-test-');
+    const manager = new WebhookManager(resultsDir);
+    manager.stopProcessing();
+
+    const fetchMock = jest.fn().mockResolvedValue({ ok: false, status: 500 });
+    global.fetch = fetchMock as unknown as typeof fetch;
+
+    manager.enqueueWebhook('job-123', basePayload, createConfig(maxAttempts));
+
+    for (let i = 0; i < expectedSends + 2; i++) {
+      await (manager as any).processQueue();
+      const queueEntry = (manager as any).deliveryQueue[0];
+      if (queueEntry) {
+        queueEntry.nextRetryTime = Date.now() - 1;
+      }
+    }
+
+    expect(fetchMock).toHaveBeenCalledTimes(expectedSends);
+    expect(manager.getQueueSize()).toBe(0);
+
+    await manager.shutdown();
+    fs.rmSync(resultsDir, { recursive: true, force: true });
+  });
+});
+
+describe('WebhookManager delivery log recovery', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test('re-enqueues pending deliveries on restart and retries immediately when retry time is stale', () => {
+    const resultsDir = fs.mkdtempSync('/tmp/kaseki-webhook-manager-recovery-test-');
+    const deliveryLogPath = `${resultsDir}/.kaseki-webhook-delivery.log`;
+
+    fs.writeFileSync(
+      deliveryLogPath,
+      [
+        JSON.stringify({
+          jobId: 'job-retry',
+          payload: {
+            eventType: WebhookEventType.JOB_FAILED,
+            jobId: 'job-retry',
+            timestamp: new Date().toISOString(),
+            data: { status: 'failed' },
+          },
+          config: {
+            url: 'https://example.com/webhook',
+            retryPolicy: { maxAttempts: 3, initialDelayMs: 100, maxDelayMs: 500 },
+          },
+          deliveryAttempts: 1,
+          attempts: [{ timestamp: new Date().toISOString(), status: 'retry' }],
+          nextRetryTime: Date.now() - 60_000,
+        }),
+      ].join('\n'),
+      'utf-8'
+    );
+
+    const manager = new WebhookManager(resultsDir);
+    manager.stopProcessing();
+
+    expect(manager.getQueueSize()).toBe(1);
+    const queueEntry = (manager as any).deliveryQueue[0];
+    expect(queueEntry.nextRetryTime).toBeGreaterThanOrEqual(Date.now() - 1000);
+
+    fs.rmSync(resultsDir, { recursive: true, force: true });
+  });
+
+  test('skips malformed lines and terminal/non-retryable entries while recovering valid pending rows', () => {
+    const resultsDir = fs.mkdtempSync('/tmp/kaseki-webhook-manager-malformed-test-');
+    const deliveryLogPath = `${resultsDir}/.kaseki-webhook-delivery.log`;
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => undefined);
+
+    fs.writeFileSync(
+      deliveryLogPath,
+      [
+        '{not-json}',
+        JSON.stringify({
+          payload: { eventType: WebhookEventType.JOB_FAILED },
+          config: { url: 'https://example.com/webhook' },
+          deliveryAttempts: 0,
+        }),
+        JSON.stringify({
+          jobId: 'job-success',
+          payload: { eventType: WebhookEventType.JOB_FAILED, jobId: 'job-success', timestamp: new Date().toISOString(), data: {} },
+          config: { url: 'https://example.com/webhook', retryPolicy: { maxAttempts: 5, initialDelayMs: 100, maxDelayMs: 500 } },
+          deliveryAttempts: 1,
+          attempts: [{ timestamp: new Date().toISOString(), status: 'success' }],
+          nextRetryTime: Date.now() + 10_000,
+        }),
+        JSON.stringify({
+          jobId: 'job-maxed',
+          payload: { eventType: WebhookEventType.JOB_FAILED, jobId: 'job-maxed', timestamp: new Date().toISOString(), data: {} },
+          config: { url: 'https://example.com/webhook', retryPolicy: { maxAttempts: 1, initialDelayMs: 100, maxDelayMs: 500 } },
+          deliveryAttempts: 1,
+          attempts: [{ timestamp: new Date().toISOString(), status: 'failed' }],
+          nextRetryTime: Date.now() + 10_000,
+        }),
+        JSON.stringify({
+          jobId: 'job-valid',
+          payload: { eventType: WebhookEventType.JOB_FAILED, jobId: 'job-valid', timestamp: new Date().toISOString(), data: {} },
+          config: { url: 'https://example.com/webhook', retryPolicy: { maxAttempts: 2, initialDelayMs: 100, maxDelayMs: 500 } },
+          deliveryAttempts: 0,
+          attempts: [{ timestamp: new Date().toISOString(), status: 'pending' }],
+          nextRetryTime: Date.now() + 10_000,
+        }),
+      ].join('\n'),
+      'utf-8'
+    );
+
+    const manager = new WebhookManager(resultsDir);
+    manager.stopProcessing();
+
+    expect(manager.getQueueSize()).toBe(1);
+    expect((manager as any).deliveryQueue[0].jobId).toBe('job-valid');
+    expect(logSpy).toHaveBeenCalled();
+
+    logSpy.mockRestore();
+    fs.rmSync(resultsDir, { recursive: true, force: true });
+  });
+});