relay-companion 0.1.0

package/src/task-daemon.js

@@ -0,0 +1,216 @@
+import { randomUUID } from "node:crypto";
+import { RelayClient } from "./client.js";
+import {
+  ensureRuntimeSession,
+  freshMessages,
+  markMessagesProcessed,
+  orderTaskMessages,
+  readTaskLedger,
+  writeTaskLedger,
+} from "./runtime.js";
+import {
+  buildHumanNotifications,
+  defaultStageRelayCompanionItem,
+  freshNotifications,
+  markNotificationsProcessed,
+} from "./notifications.js";
+
+function idempotencyKey(prefix) {
+  return `${prefix}_${randomUUID()}`;
+}
+
+function messagesForSession(session, messages) {
+  return messages.filter((message) => message.taskId === session.taskId);
+}
+
+function markProcessedOnce(ledger, processed, messages) {
+  const unseen = [];
+  for (const message of messages) {
+    if (processed.has(message.id)) continue;
+    processed.add(message.id);
+    unseen.push(message);
+  }
+  if (unseen.length) markMessagesProcessed(ledger, unseen);
+  return unseen;
+}
+
+function freshTaskEvents(ledger, events) {
+  ledger.taskEvents ||= {};
+  return events.filter((event) => {
+    const seen = ledger.taskEvents[event.id];
+    return !seen || seen.sequence !== event.sequence;
+  });
+}
+
+function markTaskEventsProcessed(ledger, events) {
+  ledger.taskEvents ||= {};
+  const processedAt = new Date().toISOString();
+  for (const event of events) {
+    ledger.taskEvents[event.id] = {
+      taskId: event.taskId,
+      sequence: event.sequence,
+      type: event.type,
+      processedAt,
+    };
+  }
+}
+
+async function pollVisibleTaskEvents({ client, ledger, tasks, log }) {
+  if (typeof client.taskEvents !== "function") return [];
+  const visibleEvents = [];
+  for (const task of tasks.tasks || []) {
+    try {
+      const result = await client.taskEvents(task.id);
+      const fresh = freshTaskEvents(ledger, result.events || []);
+      if (fresh.length) {
+        markTaskEventsProcessed(ledger, fresh);
+        for (const event of fresh) {
+          log(`observed task event ${event.id} (${event.type}) for task ${task.id}`);
+        }
+        visibleEvents.push(...fresh);
+      }
+    } catch (err) {
+      log(`task event polling failed for ${task.id}: ${err.message}`);
+    }
+  }
+  return visibleEvents;
+}
+
+async function pollHumanNotifications({ client, ledger, stageCompanionItem, log }) {
+  try {
+    const [me, tasks, relays, connectors] = await Promise.all([
+      client.me(),
+      client.listTasks(),
+      client.listRelays(),
+      client.listConnectors(),
+    ]);
+    const events = await pollVisibleTaskEvents({ client, ledger, tasks, log });
+    const notifications = buildHumanNotifications({
+      user: me.user,
+      tasks: tasks.tasks || [],
+      relays: relays.relays || [],
+      connectors: connectors.connectors || [],
+    });
+    const fresh = freshNotifications(ledger, notifications);
+    const staged = [];
+    for (const notification of fresh) {
+      try {
+        stageCompanionItem(notification);
+        staged.push(notification);
+        log(`staged Relay companion item ${notification.kind}: ${notification.title}`);
+      } catch (err) {
+        log(`Relay companion staging failed for ${notification.kind}: ${err.message}`);
+      }
+    }
+    if (staged.length) markNotificationsProcessed(ledger, staged);
+    return { notifications: staged, events };
+  } catch (err) {
+    log(`Relay companion attention polling failed: ${err.message}`);
+    return { notifications: [], events: [] };
+  }
+}
+
+export async function pollTaskRuntimeOnce({
+  client = new RelayClient(),
+  log = () => {},
+  stageCompanionItem = defaultStageRelayCompanionItem,
+  adapters,
+} = {}) {
+  const ledger = readTaskLedger();
+  const inbox = await client.agentInbox();
+  const fresh = freshMessages(ledger, inbox.messages || []);
+  const processedMessageIds = new Set();
+  const processedMessages = [];
+  const touched = [];
+
+  for (const session of inbox.sessions || []) {
+    let claimedSession = session;
+    try {
+      const claimState = session.state === "queued" || session.state === "idle" || session.state === "stale"
+        ? "starting"
+        : session.state;
+      const claimed = await client.heartbeatSession(session.id, {
+        state: claimState,
+        sessionRef: session.sessionRef || {},
+        lastError: null,
+        idempotencyKey: idempotencyKey("claim"),
+      });
+      claimedSession = claimed.session || session;
+    } catch (err) {
+      if (err.status === 409 || err.body?.error === "version_conflict") {
+        log(`session ${session.id} is leased by another companion; skipping`);
+        continue;
+      }
+      log(`claim failed for ${session.id}: ${err.message}`);
+      continue;
+    }
+    const sessionMessages = orderTaskMessages(messagesForSession(claimedSession, fresh));
+    let runtime;
+    try {
+      runtime = await ensureRuntimeSession({ session: claimedSession, messages: sessionMessages, ledger, adapters });
+    } catch (err) {
+      log(`runtime failed for ${session.id}: ${err.message}`);
+      continue;
+    }
+    processedMessages.push(...markProcessedOnce(ledger, processedMessageIds, sessionMessages));
+    touched.push(runtime);
+    try {
+      await client.heartbeatSession(session.id, {
+        state: runtime.state,
+        sessionRef: runtime.sessionRef,
+        lastError: runtime.state === "stale" ? runtime.sessionRef?.reason || "host_unavailable" : null,
+        idempotencyKey: idempotencyKey("heartbeat"),
+      });
+      await client.postDaemonEvent(session.taskId, {
+        sessionId: session.id,
+        type: "daemon.heartbeat",
+        body: `Relay companion heartbeat for ${runtime.host}.`,
+        payload: { runtimeState: runtime.state, sessionRef: runtime.sessionRef },
+        idempotencyKey: idempotencyKey("daemon_event"),
+      });
+    } catch (err) {
+      log(`heartbeat failed for ${session.id}: ${err.message}`);
+    }
+  }
+
+  if (processedMessages.length) {
+    for (const message of processedMessages) {
+      log(`received task message ${message.id} (${message.kind}) for task ${message.taskId}`);
+    }
+  }
+
+  const humanPolling = await pollHumanNotifications({ client, ledger, stageCompanionItem, log });
+  writeTaskLedger(ledger);
+  return { sessions: touched, messages: processedMessages, notifications: humanPolling.notifications, events: humanPolling.events };
+}
+
+export async function runTaskDaemon({ intervalMs = 4000 } = {}) {
+  const client = new RelayClient();
+  const me = await client.me();
+  // eslint-disable-next-line no-console
+  console.log(`[relay] task runtime for ${me.user.email}; polling every ${intervalMs}ms`);
+  // eslint-disable-next-line no-console
+  const log = (m) => console.log(`[relay] ${m}`);
+  for (;;) {
+    try {
+      const result = await pollTaskRuntimeOnce({ client, log });
+      if (result.sessions.length || result.messages.length || result.notifications.length || result.events.length) {
+        log(
+          `processed ${result.sessions.length} session(s), ${result.messages.length} message(s), ${result.notifications.length} Relay companion item(s), ${result.events.length} event(s)`,
+        );
+      }
+    } catch (err) {
+      // eslint-disable-next-line no-console
+      console.error(`[relay] task daemon error: ${err.message}`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runTaskDaemon().catch((err) => {
+    // eslint-disable-next-line no-console
+    console.error(err);
+    process.exit(1);
+  });
+}