deepline 0.2.38 → 0.2.40

package/dist/bundling-sources/sdk/src/client.ts

@@ -36,6 +36,7 @@
 import { resolveConfig } from './config.js';
 import { DeeplineError } from './errors.js';
 import { HttpClient } from './http.js';
+import { PRODUCT_NOTIFICATION_SLACK_OAUTH_SCOPES } from '../../shared_libs/product-notifications/contract.js';
 import {
   STREAM_HEALTHY_CONNECTION_MS,
   isTransientPlayStreamError,
@@ -58,6 +59,7 @@ import type {
   PlayRunPackage,
   PlayLiveEvent,
   PlayListItem,
+  ProductNotificationSettings,
   PlayDescription,
   StopPlayRunResult,
   StopAllPlayRunsResult,
@@ -3742,6 +3744,145 @@ export class DeeplineClient {
     return response.plays ?? [];
   }
 
+  /** Read product-notification destinations, subscriptions, event catalog, and DLQ health. */
+  async getNotificationSettings(): Promise<ProductNotificationSettings> {
+    return this.http.get('/api/v2/settings/notifications');
+  }
+
+  /** Start the Slack OAuth flow required by product notifications. */
+  async connectNotificationSlack(options?: {
+    successUrl?: string;
+    failureUrl?: string;
+  }): Promise<{ ok: boolean; redirect_url: string }> {
+    return this.http.post('/api/v2/integrations/connect', {
+      provider: 'slack',
+      scopes: [...PRODUCT_NOTIFICATION_SLACK_OAUTH_SCOPES],
+      ...(options?.successUrl ? { success_url: options.successUrl } : {}),
+      ...(options?.failureUrl ? { failure_url: options.failureUrl } : {}),
+    });
+  }
+
+  /** List Slack channels visible to the connected Deepline Slack app. */
+  async listNotificationSlackChannels(query?: string): Promise<{
+    identity: { teamId: string; teamName?: string };
+    channels: Array<{ id: string; name: string; isPrivate: boolean }>;
+  }> {
+    const suffix = query ? `?query=${encodeURIComponent(query)}` : '';
+    return this.http.get(`/api/v2/settings/notifications/channels${suffix}`);
+  }
+
+  /** Select the Slack channel used for product notifications. */
+  async setNotificationSlack(channel: string) {
+    return this.http.put('/api/v2/settings/notifications', { channel });
+  }
+
+  /** Send one synchronous test ping and return Slack's delivery result. */
+  async testNotificationSlack(): Promise<{
+    ok: boolean;
+    deliveryId: string;
+    state: string;
+    message: string;
+  }> {
+    return this.http.post('/api/v2/settings/notifications/test', {});
+  }
+
+  /** Disable Slack product notifications without deleting the OAuth connection. */
+  async disableNotificationSlack() {
+    return this.http.delete('/api/v2/settings/notifications');
+  }
+
+  /** Enable or disable event IDs from the server-provided notification catalog. */
+  async setNotificationSubscriptions(eventTypes: string[], enabled: boolean) {
+    return this.http.patch('/api/v2/settings/notifications/subscriptions', {
+      eventTypes,
+      enabled,
+    });
+  }
+
+  /** List exhausted deliveries. Dead-lettered messages never replay automatically. */
+  async listNotificationDlq(limit = 25) {
+    return this.http.get(
+      `/api/v2/settings/notifications/dlq?limit=${encodeURIComponent(String(limit))}`,
+    );
+  }
+
+  /** Inspect one exhausted notification delivery. */
+  async getNotificationDlqDelivery(deliveryId: string) {
+    return this.http.get(
+      `/api/v2/settings/notifications/dlq/${encodeURIComponent(deliveryId)}`,
+    );
+  }
+
+  /** Explicitly retry or archive one dead-lettered notification delivery. */
+  async updateNotificationDlqDelivery(
+    deliveryId: string,
+    action: 'retry' | 'archive',
+  ) {
+    return this.http.post(
+      `/api/v2/settings/notifications/dlq/${encodeURIComponent(deliveryId)}`,
+      { action },
+    );
+  }
+
+  /** List the workspace's named notification rules. */
+  async getNotifications(): Promise<ProductNotificationSettings> {
+    return this.http.get('/api/v2/notifications');
+  }
+
+  /** List Slack channels available to an already-connected Slack integration. */
+  async listNotificationChannels(query?: string): Promise<{
+    identity: { teamId: string; teamName?: string };
+    channels: Array<{ id: string; name: string; isPrivate: boolean }>;
+  }> {
+    const suffix = query ? `?search=${encodeURIComponent(query)}` : '';
+    return this.http.get(`/api/v2/notifications/slack/channels${suffix}`);
+  }
+
+  /** Create a named notification routed through an existing provider integration. */
+  async createNotification(input: {
+    name: string;
+    provider: 'slack';
+    channel: string;
+    eventTypes: string[];
+  }) {
+    return this.http.post('/api/v2/notifications', input);
+  }
+
+  /** Update a notification's target, event selection, or enabled state. */
+  async updateNotification(
+    notificationId: string,
+    input:
+      | { enabled: boolean }
+      | { name: string; channel: string; eventTypes: string[] },
+  ) {
+    return this.http.patch(
+      `/api/v2/notifications/${encodeURIComponent(notificationId)}`,
+      input,
+    );
+  }
+
+  /** Send a validation ping to one notification. */
+  async testNotification(notificationId: string): Promise<{
+    ok: boolean;
+    deliveryId: string;
+    state: string;
+    message: string;
+  }> {
+    return this.http.post(
+      `/api/v2/notifications/${encodeURIComponent(notificationId)}/test`,
+      {},
+    );
+  }
+
+  /** Archive one notification without touching its provider integration. */
+  async deleteNotification(
+    notificationId: string,
+  ): Promise<{ deleted: boolean; id: string }> {
+    return this.http.delete(
+      `/api/v2/notifications/${encodeURIComponent(notificationId)}`,
+    );
+  }
+
   /**
    * Search callable plays and return compact play descriptions.
    *

package/dist/bundling-sources/sdk/src/http.ts

@@ -720,6 +720,14 @@ export class HttpClient {
     });
   }
 
+  async put<T = unknown>(
+    path: string,
+    body?: unknown,
+    headers?: Record<string, string>,
+  ): Promise<T> {
+    return this.request<T>(path, { method: 'PUT', body, headers });
+  }
+
   /**
    * Send a DELETE request.
    *

package/dist/bundling-sources/sdk/src/release.ts

@@ -160,7 +160,7 @@ export const SDK_RELEASE = {
   // 0.2.0 makes Dataset Handles uniformly async-only after 0.1.320 briefly
   // exposed storage-dependent synchronous access. This deliberate minor
   // release keeps lazy paging semantics independent of row residency.
-  version: '0.2.38',
+  version: '0.2.40',
   contracts: {
     api: {
       name: 'sdk-http-api',

package/dist/bundling-sources/sdk/src/types.ts

@@ -1084,6 +1084,48 @@ export interface PlayListItem {
   currentRevision?: PlayRevisionSummary | null;
   liveRevision?: PlayRevisionSummary | null;
   aliases?: string[];
+  triggerStatus?: {
+    cron: string | null;
+    webhook: string | null;
+    blockedReason: string | null;
+  };
+}
+
+export interface ProductNotificationEventDefinition {
+  id: string;
+  label: string;
+  description: string;
+  source: 'cron' | 'webhook';
+  outcome: 'succeeded' | 'failed';
+  defaultEnabled: boolean;
+}
+
+export interface ProductNotificationSettings {
+  contractVersion: number;
+  catalog: ProductNotificationEventDefinition[];
+  notifications?: ProductNotification[];
+  providers?: Array<{ kind: string; targetLabel: string }>;
+  destinations: Array<Record<string, unknown>>;
+  subscriptions: Array<{
+    eventType: string;
+    enabled: boolean;
+    destinationId: string;
+  }>;
+  dlq: { count: number; capped: boolean };
+  slackConnection?: { connected: boolean; status: string };
+}
+
+export interface ProductNotification {
+  id: string;
+  name: string;
+  provider: string;
+  target: { id: string; name: string };
+  enabled: boolean;
+  status: string;
+  eventTypes: string[];
+  lastTestedAt?: number;
+  lastTestStatus?: string;
+  lastErrorMessage?: string;
 }
 
 export interface PlayDescription {

package/dist/bundling-sources/shared_libs/product-notifications/contract.ts

@@ -0,0 +1,134 @@
+export const PRODUCT_NOTIFICATION_CONTRACT_VERSION = 1 as const;
+
+export const PRODUCT_NOTIFICATION_EVENT_CATALOG = [
+  {
+    id: 'play.cron.succeeded',
+    label: 'Cron success',
+    description: 'A scheduled Play run completed successfully.',
+    source: 'cron',
+    outcome: 'succeeded',
+    defaultEnabled: true,
+  },
+  {
+    id: 'play.cron.failed',
+    label: 'Cron failure',
+    description:
+      'A scheduled Play could not start or its run reached a failed terminal state.',
+    source: 'cron',
+    outcome: 'failed',
+    defaultEnabled: true,
+  },
+  {
+    id: 'play.webhook.succeeded',
+    label: 'Webhook success',
+    description: 'An accepted webhook-triggered Play completed successfully.',
+    source: 'webhook',
+    outcome: 'succeeded',
+    defaultEnabled: true,
+  },
+  {
+    id: 'play.webhook.failed',
+    label: 'Webhook failure',
+    description:
+      'An accepted webhook-triggered Play reached a failed terminal state.',
+    source: 'webhook',
+    outcome: 'failed',
+    defaultEnabled: true,
+  },
+] as const;
+
+export type ProductNotificationEventDefinition =
+  (typeof PRODUCT_NOTIFICATION_EVENT_CATALOG)[number];
+export type ProductNotificationEventType =
+  ProductNotificationEventDefinition['id'];
+export type ProductNotificationSource =
+  ProductNotificationEventDefinition['source'];
+export type ProductNotificationOutcome =
+  ProductNotificationEventDefinition['outcome'];
+
+const PRODUCT_NOTIFICATION_EVENT_TYPE_SET = new Set<string>(
+  PRODUCT_NOTIFICATION_EVENT_CATALOG.map((event) => event.id),
+);
+
+export function isProductNotificationEventType(
+  value: unknown,
+): value is ProductNotificationEventType {
+  return (
+    typeof value === 'string' && PRODUCT_NOTIFICATION_EVENT_TYPE_SET.has(value)
+  );
+}
+
+export function getProductNotificationEventDefinition(
+  eventType: string,
+): ProductNotificationEventDefinition | null {
+  return (
+    PRODUCT_NOTIFICATION_EVENT_CATALOG.find(
+      (definition) => definition.id === eventType,
+    ) ?? null
+  );
+}
+
+export function defaultProductNotificationEventTypes(): ProductNotificationEventType[] {
+  return PRODUCT_NOTIFICATION_EVENT_CATALOG.filter(
+    (definition) => definition.defaultEnabled,
+  ).map((definition) => definition.id);
+}
+
+export const PRODUCT_NOTIFICATION_DESTINATION_KINDS = ['slack'] as const;
+export const PRODUCT_NOTIFICATION_SLACK_OAUTH_SCOPES = [
+  'channels:read',
+  'chat:write',
+  'groups:read',
+] as const;
+export type ProductNotificationDestinationKind =
+  (typeof PRODUCT_NOTIFICATION_DESTINATION_KINDS)[number];
+
+export const PRODUCT_NOTIFICATION_DELIVERY_STATES = [
+  'pending',
+  'delivering',
+  'delivered',
+  'retry_scheduled',
+  'dead_lettered',
+  'expired',
+  'suppressed',
+] as const;
+export type ProductNotificationDeliveryState =
+  (typeof PRODUCT_NOTIFICATION_DELIVERY_STATES)[number];
+
+/** Immediate send plus four bounded retries. */
+export const PRODUCT_NOTIFICATION_RETRY_DELAYS_MS = [
+  0,
+  60_000,
+  5 * 60_000,
+  15 * 60_000,
+  60 * 60_000,
+] as const;
+export const PRODUCT_NOTIFICATION_MAX_ATTEMPTS =
+  PRODUCT_NOTIFICATION_RETRY_DELAYS_MS.length;
+/** A claimed delivery must finish within this window or a recovery attempt may claim it. */
+export const PRODUCT_NOTIFICATION_DELIVERY_LEASE_MS = 2 * 60_000;
+
+export const PRODUCT_NOTIFICATION_PENDING_LIMIT_PER_DESTINATION = 100;
+export const PRODUCT_NOTIFICATION_DLQ_REPLAY_LIMIT = 25;
+export const PRODUCT_NOTIFICATION_SUCCESS_TTL_MS = 15 * 60_000;
+export const PRODUCT_NOTIFICATION_FAILURE_TTL_MS = 24 * 60 * 60_000;
+
+export function productNotificationEventTypeFor(input: {
+  source: ProductNotificationSource;
+  outcome: ProductNotificationOutcome;
+}): ProductNotificationEventType {
+  return `play.${input.source}.${input.outcome}` as ProductNotificationEventType;
+}
+
+export function productNotificationEventExpiresAt(input: {
+  eventType: ProductNotificationEventType;
+  occurredAt: number;
+}): number {
+  const definition = getProductNotificationEventDefinition(input.eventType);
+  return (
+    input.occurredAt +
+    (definition?.outcome === 'succeeded'
+      ? PRODUCT_NOTIFICATION_SUCCESS_TTL_MS
+      : PRODUCT_NOTIFICATION_FAILURE_TTL_MS)
+  );
+}