neondeck 1.0.0-beta.4

package/src/modules/app-state/notification-events.ts

@@ -0,0 +1,45 @@
+import type { NotificationRecord } from './types';
+
+export type NotificationEventAction =
+  'created' | 'read' | 'reconciled' | 'resolved';
+
+export type NotificationEvent = {
+  id: string;
+  action: NotificationEventAction;
+  notification: NotificationRecord;
+  changedAt: string;
+};
+
+type NotificationEventListener = (event: NotificationEvent) => void;
+
+const listeners = new Set<NotificationEventListener>();
+
+export function publishNotificationEvent(event: NotificationEvent) {
+  for (const listener of listeners) {
+    try {
+      listener(event);
+    } catch (error) {
+      listeners.delete(listener);
+      console.error('[neondeck] notification event listener failed', error);
+    }
+  }
+}
+
+export function subscribeNotificationEvents(
+  listener: NotificationEventListener,
+) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+export function formatNotificationServerSentEvent(event: NotificationEvent) {
+  return [
+    `id: ${event.id}`,
+    'event: notification-change',
+    `data: ${JSON.stringify(event)}`,
+    '',
+    '',
+  ].join('\n');
+}

package/src/modules/app-state/notifications.ts

@@ -0,0 +1,276 @@
+import { randomUUID } from 'node:crypto';
+import { asJsonValue } from '../../lib/action-result';
+import { openDb } from '../../lib/sqlite';
+import { ensureRuntimeHome, runtimePaths } from '../../runtime-home';
+import { deliverNativeNotification } from './native-notifications';
+import { publishNotificationEvent } from './notification-events';
+import type { NotificationLevel, NotificationRecord } from './types';
+
+const notificationLevelRank: Record<NotificationLevel, number> = {
+  info: 0,
+  ready: 1,
+  attention: 2,
+  urgent: 3,
+};
+
+export async function listNotifications(
+  paths = runtimePaths(),
+  options: { includeResolved?: boolean } = {},
+) {
+  await ensureRuntimeHome(paths);
+  const database = openDb(paths.neondeckDatabase);
+
+  try {
+    return database
+      .prepare(
+        `
+        SELECT *
+        FROM notifications
+        ${options.includeResolved ? '' : 'WHERE resolved_at IS NULL'}
+        ORDER BY updated_at DESC, occurrence_count DESC, created_at DESC
+        LIMIT 100;
+      `,
+      )
+      .all()
+      .map(readNotificationRow);
+  } finally {
+    database.close();
+  }
+}
+
+export async function addNotification(
+  input: {
+    level: NotificationLevel;
+    title: string;
+    message: string;
+    source?: string;
+    sourceId?: string;
+    data?: unknown;
+  },
+  paths = runtimePaths(),
+) {
+  await ensureRuntimeHome(paths);
+  const now = new Date().toISOString();
+  const source = input.source ?? null;
+  const sourceId = input.sourceId ?? null;
+  const notification: NotificationRecord = {
+    id: randomUUID(),
+    level: input.level,
+    title: input.title,
+    message: input.message,
+    source,
+    sourceId,
+    data: input.data === undefined ? null : asJsonValue(input.data),
+    readAt: null,
+    resolvedAt: null,
+    occurrenceCount: 1,
+    createdAt: now,
+    updatedAt: now,
+  };
+  const database = openDb(paths.neondeckDatabase);
+
+  try {
+    const existing =
+      source && sourceId
+        ? database
+            .prepare(
+              `
+              SELECT *
+              FROM notifications
+              WHERE source = ?
+                AND source_id = ?
+                AND resolved_at IS NULL
+              ORDER BY created_at DESC
+              LIMIT 1;
+            `,
+            )
+            .get(source, sourceId)
+        : undefined;
+
+    if (existing) {
+      const existingRecord = readNotificationRow(existing);
+      database
+        .prepare(
+          `
+          UPDATE notifications
+          SET
+            level = ?,
+            title = ?,
+            message = ?,
+            data_json = ?,
+            read_at = NULL,
+            occurrence_count = occurrence_count + 1,
+            updated_at = ?
+          WHERE id = ?;
+        `,
+        )
+        .run(
+          notification.level,
+          notification.title,
+          notification.message,
+          notification.data === null ? null : JSON.stringify(notification.data),
+          now,
+          existingRecord.id,
+        );
+
+      const reconciled = {
+        ...notification,
+        id: existingRecord.id,
+        createdAt: existingRecord.createdAt,
+        occurrenceCount: existingRecord.occurrenceCount + 1,
+      };
+      publishNotificationEvent({
+        id: reconciled.id,
+        action: 'reconciled',
+        notification: reconciled,
+        changedAt: now,
+      });
+      if (
+        notificationLevelRank[reconciled.level] >
+        notificationLevelRank[existingRecord.level]
+      ) {
+        deliverNativeNotification(reconciled);
+      }
+
+      return reconciled;
+    }
+
+    database
+      .prepare(
+        `
+        INSERT INTO notifications (
+          id,
+          level,
+          title,
+          message,
+          source,
+          source_id,
+          data_json,
+          read_at,
+          resolved_at,
+          occurrence_count,
+          created_at,
+          updated_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);
+      `,
+      )
+      .run(
+        notification.id,
+        notification.level,
+        notification.title,
+        notification.message,
+        notification.source,
+        notification.sourceId,
+        notification.data === null ? null : JSON.stringify(notification.data),
+        notification.readAt,
+        notification.resolvedAt,
+        notification.occurrenceCount,
+        notification.createdAt,
+        notification.updatedAt,
+      );
+  } finally {
+    database.close();
+  }
+
+  publishNotificationEvent({
+    id: notification.id,
+    action: 'created',
+    notification,
+    changedAt: now,
+  });
+  deliverNativeNotification(notification);
+
+  return notification;
+}
+
+export async function markNotificationRead(id: string, paths = runtimePaths()) {
+  await ensureRuntimeHome(paths);
+  const now = new Date().toISOString();
+  const database = openDb(paths.neondeckDatabase);
+
+  try {
+    const result = database
+      .prepare(
+        `
+        UPDATE notifications
+        SET read_at = ?, updated_at = ?
+        WHERE id = ?
+          AND read_at IS NULL;
+      `,
+      )
+      .run(now, now, id);
+    if (result.changes === 0) return;
+    const row = database
+      .prepare('SELECT * FROM notifications WHERE id = ?;')
+      .get(id);
+    if (row) {
+      publishNotificationEvent({
+        id,
+        action: 'read',
+        notification: readNotificationRow(row),
+        changedAt: now,
+      });
+    }
+  } finally {
+    database.close();
+  }
+}
+
+export async function resolveNotification(id: string, paths = runtimePaths()) {
+  await ensureRuntimeHome(paths);
+  const now = new Date().toISOString();
+  const database = openDb(paths.neondeckDatabase);
+
+  try {
+    const result = database
+      .prepare(
+        `
+        UPDATE notifications
+        SET resolved_at = ?, read_at = COALESCE(read_at, ?), updated_at = ?
+        WHERE id = ?
+          AND resolved_at IS NULL;
+      `,
+      )
+      .run(now, now, now, id);
+    if (result.changes === 0) return;
+    const row = database
+      .prepare('SELECT * FROM notifications WHERE id = ?;')
+      .get(id);
+    if (row) {
+      publishNotificationEvent({
+        id,
+        action: 'resolved',
+        notification: readNotificationRow(row),
+        changedAt: now,
+      });
+    }
+  } finally {
+    database.close();
+  }
+}
+
+function readNotificationRow(row: unknown): NotificationRecord {
+  const record = row as Record<string, unknown>;
+  return {
+    id: String(record.id),
+    level: String(record.level) as NotificationLevel,
+    title: String(record.title),
+    message: String(record.message),
+    source: typeof record.source === 'string' ? record.source : null,
+    sourceId: typeof record.source_id === 'string' ? record.source_id : null,
+    data:
+      typeof record.data_json === 'string'
+        ? JSON.parse(record.data_json)
+        : null,
+    readAt: typeof record.read_at === 'string' ? record.read_at : null,
+    resolvedAt:
+      typeof record.resolved_at === 'string' ? record.resolved_at : null,
+    occurrenceCount: Number(record.occurrence_count ?? 1),
+    createdAt: String(record.created_at),
+    updatedAt:
+      typeof record.updated_at === 'string'
+        ? record.updated_at
+        : String(record.created_at),
+  };
+}

package/src/modules/app-state/types.ts

@@ -0,0 +1,42 @@
+import { type JsonValue } from '@flue/runtime';
+
+export type NotificationLevel = 'info' | 'ready' | 'attention' | 'urgent';
+
+export type AutomationExecutionResult = {
+  outcome: 'silent' | 'updated' | 'recorded' | 'failed';
+  message: string;
+  result?: unknown;
+  notifications?: Array<{
+    level: NotificationLevel;
+    title: string;
+    message: string;
+    source?: string;
+    sourceId?: string;
+    data?: unknown;
+  }>;
+};
+
+export type NotificationRecord = {
+  id: string;
+  level: NotificationLevel;
+  title: string;
+  message: string;
+  source: string | null;
+  sourceId: string | null;
+  data: JsonValue | null;
+  readAt: string | null;
+  resolvedAt: string | null;
+  occurrenceCount: number;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type WorkflowSummaryRecord = {
+  id: string;
+  workflow: string;
+  runId: string | null;
+  status: string;
+  summary: JsonValue | null;
+  createdAt: string;
+  updatedAt: string;
+};

package/src/modules/app-state/workflow-summaries.ts

@@ -0,0 +1,201 @@
+import { randomUUID } from 'node:crypto';
+import { asJsonValue } from '../../lib/action-result';
+import { openDb } from '../../lib/sqlite';
+import { ensureRuntimeHome, runtimePaths } from '../../runtime-home';
+import type { WorkflowSummaryRecord } from './types';
+
+export async function addWorkflowSummary(
+  input: {
+    workflow: string;
+    runId?: string;
+    status: string;
+    summary?: unknown;
+  },
+  paths = runtimePaths(),
+) {
+  await ensureRuntimeHome(paths);
+  const now = new Date().toISOString();
+  const summary =
+    input.summary === undefined ? null : asJsonValue(input.summary);
+  const record: WorkflowSummaryRecord = {
+    id: randomUUID(),
+    workflow: input.workflow,
+    runId: input.runId ?? null,
+    status: input.status,
+    summary,
+    createdAt: now,
+    updatedAt: now,
+  };
+  const database = openDb(paths.neondeckDatabase);
+
+  try {
+    database
+      .prepare(
+        `
+        INSERT INTO workflow_summaries (
+          id,
+          workflow,
+          run_id,
+          status,
+          summary_json,
+          created_at,
+          updated_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?);
+      `,
+      )
+      .run(
+        record.id,
+        record.workflow,
+        record.runId,
+        record.status,
+        record.summary === null ? null : JSON.stringify(record.summary),
+        record.createdAt,
+        record.updatedAt,
+      );
+  } finally {
+    database.close();
+  }
+
+  return record;
+}
+
+export async function setWorkflowSummaryRunId(
+  id: string,
+  runId: string,
+  paths = runtimePaths(),
+) {
+  await ensureRuntimeHome(paths);
+  const now = new Date().toISOString();
+  const database = openDb(paths.neondeckDatabase);
+
+  try {
+    database
+      .prepare(
+        `
+        UPDATE workflow_summaries
+        SET run_id = ?, updated_at = ?
+        WHERE id = ?;
+      `,
+      )
+      .run(runId, now, id);
+  } finally {
+    database.close();
+  }
+}
+
+export async function updateWorkflowSummary(
+  id: string,
+  input: {
+    status?: string;
+    summary?: unknown;
+  },
+  paths = runtimePaths(),
+) {
+  await ensureRuntimeHome(paths);
+  const now = new Date().toISOString();
+  const database = openDb(paths.neondeckDatabase);
+
+  try {
+    database
+      .prepare(
+        `
+        UPDATE workflow_summaries
+        SET
+          status = COALESCE(?, status),
+          summary_json = COALESCE(?, summary_json),
+          updated_at = ?
+        WHERE id = ?;
+      `,
+      )
+      .run(
+        input.status ?? null,
+        input.summary === undefined
+          ? null
+          : JSON.stringify(asJsonValue(input.summary)),
+        now,
+        id,
+      );
+    const row = database
+      .prepare('SELECT * FROM workflow_summaries WHERE id = ?;')
+      .get(id);
+    return row ? readWorkflowSummaryRow(row) : undefined;
+  } finally {
+    database.close();
+  }
+}
+
+export async function listWorkflowSummaries(paths = runtimePaths()) {
+  await ensureRuntimeHome(paths);
+  const database = openDb(paths.neondeckDatabase);
+
+  try {
+    return database
+      .prepare(
+        `
+        SELECT *
+        FROM workflow_summaries
+        ORDER BY created_at DESC
+        LIMIT 100;
+      `,
+      )
+      .all()
+      .map(readWorkflowSummaryRow);
+  } finally {
+    database.close();
+  }
+}
+
+export async function findWorkflowSummaryByKiloTaskId(
+  workflow: string,
+  kiloTaskId: string,
+  paths = runtimePaths(),
+) {
+  await ensureRuntimeHome(paths);
+  const database = openDb(paths.neondeckDatabase);
+
+  try {
+    const rows = database
+      .prepare(
+        `
+        SELECT *
+        FROM workflow_summaries
+        WHERE workflow = ?
+        ORDER BY created_at DESC
+        LIMIT 200;
+      `,
+      )
+      .all(workflow)
+      .map(readWorkflowSummaryRow);
+    return (
+      rows.find((row) => {
+        const summary = objectField(row.summary);
+        return summary.kiloTaskId === kiloTaskId;
+      }) ?? null
+    );
+  } finally {
+    database.close();
+  }
+}
+
+function readWorkflowSummaryRow(row: unknown): WorkflowSummaryRecord {
+  const record = row as Record<string, unknown>;
+  return {
+    id: String(record.id),
+    workflow: String(record.workflow),
+    runId: typeof record.run_id === 'string' ? record.run_id : null,
+    status: String(record.status),
+    summary:
+      typeof record.summary_json === 'string'
+        ? JSON.parse(record.summary_json)
+        : null,
+    createdAt: String(record.created_at),
+    updatedAt: String(record.updated_at),
+  };
+}
+
+function objectField(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}