agent-relay-server 0.3.12 → 0.4.0

package/src/db.ts

@@ -7,6 +7,12 @@ import type {
   RegisterAgentInput,
   SendMessageInput,
   PollQuery,
+  Task,
+  TaskEvent,
+  TaskSeverity,
+  TaskStatus,
+  IntegrationEventInput,
+  TaskStatusInput,
 } from "./types";
 import { STALE_TTL_MS, DAY_MS } from "./config";
 
@@ -52,6 +58,58 @@ export function initDb(path: string = "agent-relay.db"): Database {
     CREATE INDEX IF NOT EXISTS idx_msg_to ON messages(to_target);
     CREATE INDEX IF NOT EXISTS idx_msg_created ON messages(created_at);
     CREATE INDEX IF NOT EXISTS idx_msg_channel ON messages(channel);
+
+    CREATE TABLE IF NOT EXISTS tasks (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      source TEXT NOT NULL,
+      title TEXT NOT NULL,
+      body TEXT NOT NULL,
+      severity TEXT NOT NULL,
+      status TEXT NOT NULL,
+      target TEXT NOT NULL,
+      channel TEXT,
+      dedupe_key TEXT,
+      external_url TEXT,
+      occurrence_count INTEGER NOT NULL DEFAULT 1,
+      claimed_by TEXT,
+      claimed_at INTEGER,
+      message_id INTEGER REFERENCES messages(id) ON DELETE SET NULL,
+      result TEXT,
+      metadata TEXT NOT NULL DEFAULT '{}',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      last_seen_at INTEGER NOT NULL
+    );
+
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_tasks_source_dedupe ON tasks(source, dedupe_key) WHERE dedupe_key IS NOT NULL AND status NOT IN ('done', 'failed', 'canceled');
+    CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+    CREATE INDEX IF NOT EXISTS idx_tasks_target ON tasks(target);
+    CREATE INDEX IF NOT EXISTS idx_tasks_updated ON tasks(updated_at);
+
+    CREATE TABLE IF NOT EXISTS task_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      task_id INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+      source TEXT NOT NULL,
+      type TEXT NOT NULL,
+      severity TEXT NOT NULL,
+      title TEXT NOT NULL,
+      body TEXT NOT NULL,
+      metadata TEXT NOT NULL DEFAULT '{}',
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS task_callback_deliveries (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      task_id INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+      url TEXT NOT NULL,
+      event_type TEXT NOT NULL,
+      payload TEXT NOT NULL,
+      status TEXT NOT NULL,
+      attempts INTEGER NOT NULL DEFAULT 0,
+      last_error TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
   `);
 
   // Migrations
@@ -124,6 +182,7 @@ export function initDb(path: string = "agent-relay.db"): Database {
 }
 
 export class ValidationError extends Error {}
+class ClaimError extends Error {}
 
 function parseJson<T>(raw: string, fallback: T): T {
   try {
@@ -133,15 +192,21 @@ function parseJson<T>(raw: string, fallback: T): T {
   }
 }
 
+function parseStringArray(raw: string): string[] {
+  const parsed = parseJson<unknown>(raw, []);
+  if (!Array.isArray(parsed)) return [];
+  return parsed.filter((value): value is string => typeof value === "string");
+}
+
 function rowToAgent(row: any): AgentCard {
   return {
     id: row.id,
     name: row.name,
     label: row.label ?? undefined,
-    tags: parseJson(row.tags, []),
+    tags: parseStringArray(row.tags),
     machine: row.machine ?? undefined,
     rig: row.rig ?? undefined,
-    capabilities: parseJson(row.capabilities, []),
+    capabilities: parseStringArray(row.capabilities),
     ready: row.ready === 1,
     status: row.status,
     meta: parseJson(row.meta, {}),
@@ -170,6 +235,44 @@ function rowToMessage(row: any): Message {
   };
 }
 
+function rowToTask(row: any): Task {
+  return {
+    id: row.id,
+    source: row.source,
+    title: row.title,
+    body: row.body,
+    severity: row.severity as TaskSeverity,
+    status: row.status as TaskStatus,
+    target: row.target,
+    channel: row.channel ?? undefined,
+    dedupeKey: row.dedupe_key ?? undefined,
+    externalUrl: row.external_url ?? undefined,
+    occurrenceCount: row.occurrence_count,
+    claimedBy: row.claimed_by ?? undefined,
+    claimedAt: row.claimed_at ?? undefined,
+    messageId: row.message_id ?? undefined,
+    result: row.result ?? undefined,
+    metadata: parseJson(row.metadata, {}),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    lastSeenAt: row.last_seen_at,
+  };
+}
+
+function rowToTaskEvent(row: any): TaskEvent {
+  return {
+    id: row.id,
+    taskId: row.task_id,
+    source: row.source,
+    type: row.type,
+    severity: row.severity as TaskSeverity,
+    title: row.title,
+    body: row.body,
+    metadata: parseJson(row.metadata, {}),
+    createdAt: row.created_at,
+  };
+}
+
 const MSG_SELECT = `SELECT m.*, (
   SELECT json_group_array(agent_id) FROM message_reads WHERE message_id = m.id
 ) AS read_by_agents FROM messages m`;
@@ -306,6 +409,12 @@ export function pruneOfflineAgents(maxOfflineMs: number = DAY_MS): string[] {
       )
       .run(cutoff);
 
+    db
+      .prepare(
+        "UPDATE tasks SET status = 'open', claimed_by = NULL, claimed_at = NULL, updated_at = ? WHERE claimed_by IN (SELECT id FROM agents WHERE status = 'offline' AND last_seen < ? AND id NOT IN ('user', 'system')) AND status IN ('claimed', 'in_progress', 'blocked')"
+      )
+      .run(Date.now(), cutoff);
+
     db
       .prepare(
         "DELETE FROM agents WHERE status = 'offline' AND last_seen < ? AND id NOT IN ('user', 'system')"
@@ -328,16 +437,277 @@ export function findAgentsByCapability(capability: string, onlineOnly = true): A
 }
 
 export function deleteAgent(id: string): { ok: boolean; error?: string } {
-  if (id === "user") return { ok: false, error: "built-in user agent cannot be deleted" };
+  if (id === "user" || id === "system") {
+    return { ok: false, error: "built-in agent cannot be deleted" };
+  }
   const deleted = db.transaction(() => {
     // Release any claims held by this agent so the tasks become claimable again.
     // from_agent is left intact as historical record.
     db.prepare("UPDATE messages SET claimed_by = NULL, claimed_at = NULL WHERE claimed_by = ?").run(id);
+    db.prepare("UPDATE tasks SET status = 'open', claimed_by = NULL, claimed_at = NULL, updated_at = ? WHERE claimed_by = ? AND status IN ('claimed', 'in_progress', 'blocked')").run(Date.now(), id);
     return db.prepare("DELETE FROM agents WHERE id = ?").run(id).changes > 0;
   })();
   return deleted ? { ok: true } : { ok: false, error: "agent not found" };
 }
 
+// --- Tasks ---
+
+const TASK_SELECT = "SELECT * FROM tasks";
+
+function findOpenTaskByDedupe(source: string, dedupeKey: string): Task | null {
+  const row = db
+    .prepare(`${TASK_SELECT} WHERE source = ? AND dedupe_key = ? AND status NOT IN ('done', 'failed', 'canceled') ORDER BY id DESC LIMIT 1`)
+    .get(source, dedupeKey) as any;
+  return row ? rowToTask(row) : null;
+}
+
+function insertTaskEvent(taskId: number, event: Required<Omit<TaskEvent, "id" | "taskId" | "createdAt">>, now: number): TaskEvent {
+  const result = db.prepare(`
+    INSERT INTO task_events (task_id, source, type, severity, title, body, metadata, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(taskId, event.source, event.type, event.severity, event.title, event.body, JSON.stringify(event.metadata), now);
+  return getTaskEvent(Number(result.lastInsertRowid))!;
+}
+
+function getTaskEvent(id: number): TaskEvent | null {
+  const row = db.prepare("SELECT * FROM task_events WHERE id = ?").get(id) as any;
+  return row ? rowToTaskEvent(row) : null;
+}
+
+function taskMessageBody(task: Pick<Task, "id" | "source" | "severity" | "body" | "externalUrl" | "dedupeKey">): string {
+  const lines = [
+    `[task:${task.id}] ${task.severity.toUpperCase()} from ${task.source}`,
+    "",
+    task.body,
+  ];
+  if (task.externalUrl) lines.push("", `External: ${task.externalUrl}`);
+  if (task.dedupeKey) lines.push(`Dedupe: ${task.dedupeKey}`);
+  lines.push("", "Claim this task before working it, then update task status when finished.");
+  return lines.join("\n");
+}
+
+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;
+
+  return db.transaction(() => {
+    const existing = input.dedupeKey ? findOpenTaskByDedupe(source, input.dedupeKey) : null;
+    let taskId: number;
+    let created = false;
+
+    if (existing) {
+      db.prepare(`
+        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 = db.prepare(`
+        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)!;
+    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,
+        type: "system",
+        channel: task.channel,
+        subject: `[${task.severity}] ${task.title}`,
+        body: taskMessageBody(task),
+        claimable: true,
+        meta: {
+          taskId: task.id,
+          source: task.source,
+          severity: task.severity,
+          dedupeKey: task.dedupeKey ?? null,
+          externalUrl: task.externalUrl ?? null,
+        },
+      });
+      db.prepare("UPDATE tasks SET message_id = ?, updated_at = ? WHERE id = ?").run(message.id, now, task.id);
+    }
+
+    return { task: getTask(taskId)!, event, created, message };
+  })();
+}
+
+export function getTask(id: number): Task | null {
+  const row = db.prepare(`${TASK_SELECT} WHERE id = ?`).get(id) as any;
+  return row ? rowToTask(row) : null;
+}
+
+export function listTasks(filter?: { status?: string; source?: string; target?: string; limit?: number }): Task[] {
+  const conditions: string[] = [];
+  const params: any[] = [];
+  if (filter?.status) {
+    conditions.push("status = ?");
+    params.push(filter.status);
+  }
+  if (filter?.source) {
+    conditions.push("source = ?");
+    params.push(filter.source);
+  }
+  if (filter?.target) {
+    conditions.push("target = ?");
+    params.push(filter.target);
+  }
+  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+  params.push(filter?.limit ?? 100);
+  return (db.prepare(`${TASK_SELECT} ${where} ORDER BY updated_at DESC LIMIT ?`).all(...params) as any[]).map(rowToTask);
+}
+
+export function listTaskEvents(taskId: number): TaskEvent[] {
+  return (db.prepare("SELECT * FROM task_events WHERE task_id = ? ORDER BY id ASC").all(taskId) as any[]).map(rowToTaskEvent);
+}
+
+export function claimTask(taskId: number, agentId: string): { ok: boolean; error?: string; task?: Task } {
+  const agent = getAgent(agentId);
+  if (!agent) return { ok: false, error: "claiming agent not found" };
+  if (agent.status === "offline") return { ok: false, error: "claiming agent is offline" };
+  const task = getTask(taskId);
+  if (!task) return { ok: false, error: "task not found" };
+  if (!["open", "blocked"].includes(task.status)) return { ok: false, error: `task is ${task.status}` };
+
+  try {
+    return db.transaction(() => {
+      const now = Date.now();
+      const result = db.prepare(`
+        UPDATE tasks SET status = 'claimed', claimed_by = ?, claimed_at = ?, updated_at = ?
+        WHERE id = ? AND status IN ('open', 'blocked')
+      `).run(agentId, now, now, taskId);
+      if (result.changes === 0) return { ok: false, error: "claim race — already claimed" };
+      if (task.messageId) {
+        const messageClaim = claimMessageRow(task.messageId, agentId, now);
+        if (!messageClaim.ok) throw new ClaimError(messageClaim.error);
+      }
+      insertTaskEvent(taskId, {
+        source: "agent-relay",
+        type: "claimed",
+        severity: task.severity,
+        title: `Task claimed by ${agentId}`,
+        body: `Task claimed by ${agentId}`,
+        metadata: { agentId },
+      }, now);
+      return { ok: true, task: getTask(taskId)! };
+    })();
+  } catch (e) {
+    if (e instanceof ClaimError) return { ok: false, error: e.message };
+    throw e;
+  }
+}
+
+export function updateTaskStatus(taskId: number, input: TaskStatusInput): { ok: boolean; error?: string; task?: Task; event?: TaskEvent } {
+  const task = getTask(taskId);
+  if (!task) return { ok: false, error: "task not found" };
+  const now = Date.now();
+  const agentId = input.agentId ?? task.claimedBy ?? null;
+  const result = db.prepare(`
+    UPDATE tasks
+    SET status = ?, result = COALESCE(?, result), claimed_by = COALESCE(?, claimed_by),
+        claimed_at = CASE WHEN claimed_by IS NULL AND ? IS NOT NULL THEN ? ELSE claimed_at END,
+        updated_at = ?, last_seen_at = ?
+    WHERE id = ?
+  `).run(input.status, input.result ?? null, agentId, agentId, now, now, now, taskId);
+  if (result.changes === 0) return { ok: false, error: "task not found" };
+  const event = insertTaskEvent(taskId, {
+    source: input.agentId ?? "agent-relay",
+    type: `status:${input.status}`,
+    severity: task.severity,
+    title: `Task ${input.status}`,
+    body: input.body ?? input.result ?? `Task marked ${input.status}`,
+    metadata: input.metadata ?? {},
+  }, now);
+  return { ok: true, task: getTask(taskId)!, event };
+}
+
+export function createCallbackDelivery(taskId: number, url: string, eventType: string, payload: unknown): number {
+  const now = Date.now();
+  const result = db.prepare(`
+    INSERT INTO task_callback_deliveries (task_id, url, event_type, payload, status, attempts, created_at, updated_at)
+    VALUES (?, ?, ?, ?, 'pending', 0, ?, ?)
+  `).run(taskId, url, eventType, JSON.stringify(payload), now, now);
+  return Number(result.lastInsertRowid);
+}
+
+export function finishCallbackDelivery(id: number, ok: boolean, error?: string): void {
+  db.prepare(`
+    UPDATE task_callback_deliveries
+    SET status = ?, attempts = attempts + 1, last_error = ?, updated_at = ?
+    WHERE id = ?
+  `).run(ok ? "delivered" : "failed", error ?? null, Date.now(), id);
+}
+
+export function listCallbackDeliveries(taskId: number): Array<{
+  id: number;
+  taskId: number;
+  url: string;
+  eventType: string;
+  status: string;
+  attempts: number;
+  lastError?: string;
+}> {
+  return (db.prepare("SELECT * FROM task_callback_deliveries WHERE task_id = ? ORDER BY id ASC").all(taskId) as any[])
+    .map((row) => ({
+      id: row.id,
+      taskId: row.task_id,
+      url: row.url,
+      eventType: row.event_type,
+      status: row.status,
+      attempts: row.attempts,
+      lastError: row.last_error ?? undefined,
+    }));
+}
+
 // --- Messages ---
 
 export function sendMessage(input: SendMessageInput): Message {
@@ -395,23 +765,66 @@ export function getThread(messageId: number): Message[] {
   ).map(rowToMessage);
 }
 
-export function claimMessage(messageId: number, agentId: string): { ok: boolean; error?: string } {
-  if (!getAgent(agentId)) return { ok: false, error: "claiming agent not found" };
-
-  const msg = getMessage(messageId);
-  if (!msg) return { ok: false, error: "message not found" };
-  if (!msg.claimable) return { ok: false, error: "message is not claimable" };
-  if (msg.claimedBy) return { ok: false, error: `already claimed by ${msg.claimedBy}` };
-
+function claimMessageRow(messageId: number, agentId: string, now: number): { ok: false; error: string } | { ok: true } {
   const result = db.prepare(
     "UPDATE messages SET claimed_by = ?, claimed_at = ? WHERE id = ? AND claimed_by IS NULL"
-  ).run(agentId, Date.now(), messageId);
+  ).run(agentId, now, messageId);
 
   // Atomic: if changes === 0, someone else claimed it between our read and write
   if (result.changes === 0) return { ok: false, error: "claim race — already claimed" };
   return { ok: true };
 }
 
+export function claimMessage(messageId: number, agentId: string): { ok: boolean; error?: string; task?: Task } {
+  const agent = getAgent(agentId);
+  if (!agent) return { ok: false, error: "claiming agent not found" };
+  if (agent.status === "offline") return { ok: false, error: "claiming agent is offline" };
+
+  const msg = getMessage(messageId);
+  if (!msg) return { ok: false, error: "message not found" };
+  if (!msg.claimable) return { ok: false, error: "message is not claimable" };
+  if (msg.claimedBy) return { ok: false, error: `already claimed by ${msg.claimedBy}` };
+
+  try {
+    return db.transaction(() => {
+      const now = Date.now();
+      const messageClaim = claimMessageRow(messageId, agentId, now);
+      if (!messageClaim.ok) return messageClaim;
+
+      const taskId = typeof msg.meta?.taskId === "number" && Number.isSafeInteger(msg.meta.taskId)
+        ? msg.meta.taskId
+        : null;
+      if (!taskId) return { ok: true };
+
+      const task = getTask(taskId);
+      if (!task) return { ok: true };
+      if (!["open", "blocked"].includes(task.status)) {
+        throw new ClaimError(`linked task is ${task.status}`);
+      }
+
+      const taskClaim = db.prepare(`
+        UPDATE tasks SET status = 'claimed', claimed_by = ?, claimed_at = ?, updated_at = ?
+        WHERE id = ? AND message_id = ? AND status IN ('open', 'blocked')
+      `).run(agentId, now, now, taskId, messageId);
+      if (taskClaim.changes === 0) throw new ClaimError("linked task claim race — already claimed");
+
+      insertTaskEvent(taskId, {
+        source: "agent-relay",
+        type: "claimed",
+        severity: task.severity,
+        title: `Task claimed by ${agentId}`,
+        body: `Task claimed by ${agentId}`,
+        metadata: { agentId, messageId },
+      }, now);
+
+      return { ok: true, task: getTask(taskId)! };
+    })();
+  } catch (e) {
+    if (e instanceof ClaimError) return { ok: false, error: e.message };
+    throw e;
+  }
+}
+
 export function getMessage(id: number): Message | null {
   const row = db.prepare(`${MSG_SELECT} WHERE m.id = ?`).get(id) as any;
   return row ? rowToMessage(row) : null;
@@ -520,9 +933,14 @@ export function getLatestMessageId(): number {
 
 export function pruneOldMessages(maxAgeMs: number): number {
   const cutoff = Date.now() - maxAgeMs;
-  return db
-    .prepare("DELETE FROM messages WHERE created_at < ?")
-    .run(cutoff).changes;
+  return db.transaction(() => {
+    db
+      .prepare("UPDATE messages SET reply_to = NULL WHERE reply_to IN (SELECT id FROM messages WHERE created_at < ?)")
+      .run(cutoff);
+    return db
+      .prepare("DELETE FROM messages WHERE created_at < ?")
+      .run(cutoff).changes;
+  })();
 }
 
 export function getStats(): {
@@ -531,6 +949,8 @@ export function getStats(): {
   online: number;
   messages: number;
   messagesLast24h: number;
+  tasks: number;
+  openTasks: number;
 } {
   const agents = (
     db.prepare("SELECT COUNT(*) as c FROM agents").get() as any
@@ -550,6 +970,12 @@ export function getStats(): {
       .prepare("SELECT COUNT(*) as c FROM messages WHERE created_at > ?")
       .get(Date.now() - DAY_MS) as any
   ).c;
+  const tasks = (
+    db.prepare("SELECT COUNT(*) as c FROM tasks").get() as any
+  ).c;
+  const openTasks = (
+    db.prepare("SELECT COUNT(*) as c FROM tasks WHERE status NOT IN ('done', 'failed', 'canceled')").get() as any
+  ).c;
 
-  return { version: VERSION, agents, online, messages, messagesLast24h };
+  return { version: VERSION, agents, online, messages, messagesLast24h, tasks, openTasks };
 }