agent-relay-server 0.33.0 → 0.33.1

package/src/db/integrations.ts

@@ -0,0 +1,339 @@
+import { Database } from "bun:sqlite";
+import { randomUUID } from "node:crypto";
+import { isRecord, stringValue, isMechanicalMessageKind } from "agent-relay-sdk";
+import { ORCHESTRATOR_PROTOCOL_VERSION, VERSION } from "../config.ts";
+import { parseJson } from "../utils";
+import { isLiveIsolatedWorkspace } from "../workspace-phase";
+import {
+  CONTRACT_REQUIREMENTS,
+  contractCompatibility,
+  parseRuntimeCapabilities,
+  parseRuntimeContracts,
+  parseRuntimePackage,
+  type RuntimeContracts,
+} from "../contracts";
+import { STALE_TTL_MS, DAY_MS, CLAIM_LEASE_MS, POOL_CLAIM_LEASE_MS, WORKSPACE_MERGE_LEASE_MS } from "../config";
+import { matchAgents } from "../agent-ref";
+import { normalizeTags, parseStringArray } from "./agents.ts";
+import { linkAttachmentRefs, validateAttachmentRefs } from "./artifacts.ts";
+import { ValidationError, getDb } from "./connection.ts";
+import { sendMessage } from "./messages.ts";
+import { findOpenTaskByDedupe, getTask, insertTaskEvent, taskMessageBody } from "./tasks.ts";
+import type {
+  AgentCard,
+  ActivityEvent,
+  ActivityEventInput,
+  AgentKind,
+  AgentSessionGuard,
+  Artifact,
+  ArtifactBlob,
+  ArtifactKind,
+  ArtifactLink,
+  ArtifactSensitivity,
+  ArtifactVisibility,
+  AttachmentRef,
+  ChannelBinding,
+  ChannelBindingMode,
+  ChannelRouteTarget,
+  ChatHistoryImport,
+  ChatHistoryImportEntry,
+  ChannelSummary,
+  ChannelTargetHealth,
+  CreatePairInput,
+  HealthCheck,
+  HealthReport,
+  ManagedAgent,
+  ManagedSessionExitDiagnostics,
+  Message,
+  MessageDeliveryAttempt,
+  MessageDeliveryStatus,
+  Orchestrator,
+  OrchestratorHealth,
+  OrchestratorRuntimeInput,
+  OrchestratorStatus,
+  OrchestratorUpgradeState,
+  PairActionInput,
+  PairMessageInput,
+  PairSession,
+  PairStatus,
+  RegisterAgentInput,
+  ReplyObligation,
+  RegisterOrchestratorInput,
+  SendMessageInput,
+  PollQuery,
+  SpawnApprovalMode,
+  SpawnProvider,
+  Task,
+  TaskEvent,
+  TaskSeverity,
+  TaskStatus,
+  IntegrationEventInput,
+  IntegrationSummary,
+  IntegrationTaskStats,
+  InboxDraft,
+  InboxState,
+  InboxThreadState,
+  ContextSnapshot,
+  ContextState,
+  ProviderCapabilities,
+  TaskStatusInput,
+  WorkspaceMetadata,
+  WorkspaceRecord,
+  WorkspaceStatus,
+} from "../types";
+
+export function ingestIntegrationEvent(input: IntegrationEventInput, integrationName: string): { task: Task; event: TaskEvent; created: boolean; message?: Message } {
+  const now = Date.now();
+  const source = input.source ?? integrationName;
+  const severity = input.severity ?? "info";
+  const eventType = input.type ?? "event";
+  const targetStatus = input.status === "resolved" ? "done" : input.status;
+  const attachmentRefs = input.attachments ?? [];
+  validateAttachmentRefs(attachmentRefs);
+  updateIntegrationObserved(source, now);
+
+  return getDb().transaction(() => {
+    const existing = input.dedupeKey ? findOpenTaskByDedupe(source, input.dedupeKey) : null;
+    let taskId: number;
+    let created = false;
+
+    if (existing) {
+      getDb().query(`
+        UPDATE tasks
+        SET title = ?, body = ?, severity = ?, target = ?, channel = ?, external_url = ?,
+            occurrence_count = occurrence_count + 1, metadata = ?, updated_at = ?, last_seen_at = ?,
+            status = CASE WHEN ? IS NULL THEN status ELSE ? END,
+            result = CASE WHEN ? IN ('done', 'failed', 'canceled') THEN ? ELSE result END
+        WHERE id = ?
+      `).run(
+        input.title,
+        input.body,
+        severity,
+        input.target,
+        input.channel ?? null,
+        input.externalUrl ?? null,
+        JSON.stringify(input.metadata ?? existing.metadata),
+        now,
+        now,
+        targetStatus ?? null,
+        targetStatus ?? null,
+        targetStatus ?? null,
+        input.body,
+        existing.id,
+      );
+      taskId = existing.id;
+    } else {
+      const result = getDb().query(`
+        INSERT INTO tasks (source, title, body, severity, status, target, channel, dedupe_key, external_url, metadata, created_at, updated_at, last_seen_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        source,
+        input.title,
+        input.body,
+        severity,
+        targetStatus ?? "open",
+        input.target,
+        input.channel ?? null,
+        input.dedupeKey ?? null,
+        input.externalUrl ?? null,
+        JSON.stringify(input.metadata ?? {}),
+        now,
+        now,
+        now,
+      );
+      taskId = Number(result.lastInsertRowid);
+      created = true;
+    }
+
+    const task = getTask(taskId)!;
+    linkAttachmentRefs("task", task.id, attachmentRefs, source);
+    const event = insertTaskEvent(taskId, {
+      source,
+      type: eventType,
+      severity,
+      title: input.title,
+      body: input.body,
+      metadata: input.metadata ?? {},
+    }, now);
+
+    let message: Message | undefined;
+    if (created && task.status === "open") {
+      message = sendMessage({
+        from: "system",
+        to: task.target,
+        kind: "task",
+        channel: task.channel,
+        subject: `[${task.severity}] ${task.title}`,
+        body: taskMessageBody(task),
+        claimable: true,
+        payload: {
+          taskId: task.id,
+          source: task.source,
+          title: task.title,
+          status: task.status,
+          severity: task.severity,
+          dedupeKey: task.dedupeKey ?? null,
+          externalUrl: task.externalUrl ?? null,
+          ...(attachmentRefs.length ? { attachments: attachmentRefs } : {}),
+        },
+      });
+      getDb().query("UPDATE tasks SET message_id = ?, updated_at = ? WHERE id = ?").run(message.id, now, task.id);
+    }
+
+    return { task: getTask(taskId)!, event, created, message };
+  })();
+}
+
+
+export function listIntegrationTaskStats(): IntegrationTaskStats[] {
+  const rows = getDb().query(`
+    SELECT
+      source,
+      COUNT(*) AS tasks,
+      SUM(CASE WHEN status NOT IN ('done', 'failed', 'canceled') THEN 1 ELSE 0 END) AS open_tasks,
+      SUM(CASE WHEN status IN ('open', 'blocked') AND claimed_by IS NULL THEN 1 ELSE 0 END) AS waiting_tasks,
+      SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) AS failed_tasks,
+      MAX(last_seen_at) AS last_seen_at,
+      MAX(updated_at) AS last_updated_at
+    FROM tasks
+    GROUP BY source
+    ORDER BY last_seen_at DESC, source ASC
+  `).all() as any[];
+
+  return rows.map((row) => ({
+    source: row.source,
+    tasks: Number(row.tasks ?? 0),
+    openTasks: Number(row.open_tasks ?? 0),
+    waitingTasks: Number(row.waiting_tasks ?? 0),
+    failedTasks: Number(row.failed_tasks ?? 0),
+    lastSeenAt: row.last_seen_at ?? undefined,
+    lastUpdatedAt: row.last_updated_at ?? undefined,
+  }));
+}
+
+export type IntegrationRegistryInput = {
+  name: string;
+  displayName?: string;
+  description?: string;
+  enabled?: boolean;
+  scopes?: string[];
+  targets?: string[];
+  channels?: string[];
+  type?: string;
+  icon?: string;
+  accentColor?: string;
+  tags?: string[];
+  homepageUrl?: string;
+  repositoryUrl?: string;
+  docsUrl?: string;
+  manifest?: Record<string, unknown>;
+  source?: "api" | "env" | "observed";
+};
+
+export function rowToIntegrationRegistry(row: any): Omit<IntegrationSummary, "configured" | "observed" | "callbackConfigured" | "rateLimit" | "taskStats"> & {
+  source: "api" | "env" | "observed";
+  lastEventAt?: number;
+  lastTaskAt?: number;
+  lastAuthSuccessAt?: number;
+  lastAuthFailureAt?: number;
+} {
+  return {
+    name: row.name,
+    displayName: row.display_name ?? undefined,
+    description: row.description ?? undefined,
+    enabled: row.enabled !== 0,
+    scopes: parseStringArray(row.scopes),
+    targets: parseStringArray(row.targets),
+    channels: parseStringArray(row.channels),
+    type: row.type ?? undefined,
+    icon: row.icon ?? undefined,
+    accentColor: row.accent_color ?? undefined,
+    tags: parseStringArray(row.tags),
+    homepageUrl: row.homepage_url ?? undefined,
+    repositoryUrl: row.repository_url ?? undefined,
+    docsUrl: row.docs_url ?? undefined,
+    manifest: parseJson(row.manifest, {}),
+    source: row.source ?? "api",
+    lastEventAt: row.last_event_at ?? undefined,
+    lastTaskAt: row.last_task_at ?? undefined,
+    lastAuthSuccessAt: row.last_auth_success_at ?? undefined,
+    lastAuthFailureAt: row.last_auth_failure_at ?? undefined,
+  };
+}
+
+export function upsertIntegrationRegistry(input: IntegrationRegistryInput): ReturnType<typeof rowToIntegrationRegistry> {
+  const name = stringValue(input.name);
+  if (!name) throw new ValidationError("integration name required");
+  const now = Date.now();
+  getDb().query(`
+    INSERT INTO integration_registry (
+      name, display_name, description, enabled, scopes, targets, channels, type, icon, accent_color,
+      tags, homepage_url, repository_url, docs_url, manifest, source, created_at, updated_at
+    )
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(name) DO UPDATE SET
+      display_name = coalesce(excluded.display_name, integration_registry.display_name),
+      description = coalesce(excluded.description, integration_registry.description),
+      enabled = CASE WHEN integration_registry.source = 'api' AND excluded.source IN ('env', 'observed') THEN integration_registry.enabled ELSE excluded.enabled END,
+      scopes = CASE WHEN excluded.scopes <> '[]' THEN excluded.scopes ELSE integration_registry.scopes END,
+      targets = CASE WHEN excluded.targets <> '[]' THEN excluded.targets ELSE integration_registry.targets END,
+      channels = CASE WHEN excluded.channels <> '[]' THEN excluded.channels ELSE integration_registry.channels END,
+      type = coalesce(excluded.type, integration_registry.type),
+      icon = coalesce(excluded.icon, integration_registry.icon),
+      accent_color = coalesce(excluded.accent_color, integration_registry.accent_color),
+      tags = CASE WHEN excluded.tags <> '[]' THEN excluded.tags ELSE integration_registry.tags END,
+      homepage_url = coalesce(excluded.homepage_url, integration_registry.homepage_url),
+      repository_url = coalesce(excluded.repository_url, integration_registry.repository_url),
+      docs_url = coalesce(excluded.docs_url, integration_registry.docs_url),
+      manifest = CASE WHEN excluded.manifest <> '{}' THEN excluded.manifest ELSE integration_registry.manifest END,
+      source = CASE WHEN integration_registry.source = 'api' AND excluded.source IN ('env', 'observed') THEN integration_registry.source ELSE excluded.source END,
+      updated_at = excluded.updated_at
+  `).run(
+    name,
+    input.displayName ?? null,
+    input.description ?? null,
+    input.enabled === false ? 0 : 1,
+    JSON.stringify(input.scopes ?? []),
+    JSON.stringify(input.targets ?? []),
+    JSON.stringify(input.channels ?? []),
+    input.type ?? null,
+    input.icon ?? null,
+    input.accentColor ?? null,
+    JSON.stringify(normalizeTags(input.tags)),
+    input.homepageUrl ?? null,
+    input.repositoryUrl ?? null,
+    input.docsUrl ?? null,
+    JSON.stringify(input.manifest ?? {}),
+    input.source ?? "api",
+    now,
+    now,
+  );
+  return getIntegrationRegistry(name)!;
+}
+
+export function getIntegrationRegistry(name: string): ReturnType<typeof rowToIntegrationRegistry> | null {
+  const row = getDb().query("SELECT * FROM integration_registry WHERE name = ?").get(name) as any;
+  return row ? rowToIntegrationRegistry(row) : null;
+}
+
+export function listIntegrationRegistry(): ReturnType<typeof rowToIntegrationRegistry>[] {
+  return (getDb().query("SELECT * FROM integration_registry ORDER BY display_name COLLATE NOCASE, name COLLATE NOCASE").all() as any[]).map(rowToIntegrationRegistry);
+}
+
+export function updateIntegrationObserved(name: string, eventAt: number): void {
+  const now = Date.now();
+  getDb().query(`
+    INSERT INTO integration_registry (name, enabled, scopes, targets, channels, tags, manifest, source, created_at, updated_at, last_event_at, last_task_at)
+    VALUES (?, 1, '[]', '[]', '[]', '[]', '{}', 'observed', ?, ?, ?, ?)
+    ON CONFLICT(name) DO UPDATE SET
+      last_event_at = max(coalesce(last_event_at, 0), excluded.last_event_at),
+      last_task_at = max(coalesce(last_task_at, 0), excluded.last_task_at),
+      updated_at = excluded.updated_at
+  `).run(name, now, now, eventAt, eventAt);
+}
+
+export function isIntegrationRegistryEnabled(name: string): boolean {
+  const registry = getIntegrationRegistry(name);
+  return registry?.enabled !== false;
+}
+