@oar-sh/oar 0.9.10 → 0.9.12

package/server/services/remote-relay-dispatcher.mjs

@@ -27,6 +27,7 @@ import {
 import { schemaFields } from '../../shared/question-schema.mjs';
 import { ANSWERED_ELSEWHERE_KIND } from '../../shared/steer-settle-markers.mjs';
 import { RELAY_EVENT_DEFAULT_TYPES } from '../../shared/relay-events.mjs';
+import { cleanTaskOutput, parseRunnerSummary, stallMinutes, stripSgr } from '../../shared/task-output-text.mjs';
 import {
   RELAY_EVENT_REMOTE_PULL_PATH,
   RELAY_EVENT_REMOTE_SUBSCRIBE_PATH,
@@ -1238,7 +1239,21 @@ export function createRemoteRelayDispatcher({
     }
   }
 
-  function mapSession(row, workerIds, ctx = null) {
+  /** The session group of a listed row: id, display name and the row's role. */
+  function sessionGroupField(row, groups) {
+    const groupId = toText(row?.groupId);
+    if (!groupId) return {};
+    const info = isPlainObject(groups?.[groupId]) ? groups[groupId] : null;
+    return {
+      group: {
+        id: groupId,
+        name: toText(info?.displayName) || toText(info?.name) || null,
+        role: toText(row?.groupRole) === 'head' ? 'head' : 'member',
+      },
+    };
+  }
+
+  function mapSession(row, workerIds, ctx = null, groups = null) {
     const id = toText(row?.id);
     const via = toText(row?.origin?.relayName);
     // A session an agent of that relay created there, and from which session.
@@ -1256,6 +1271,9 @@ export function createRemoteRelayDispatcher({
       ...(via ? { via } : {}),
       ...(createdBy ? { createdBy } : {}),
       ...(createdBy && ctx?.relay?.local && createdBy === ctx.conversationId ? { startedByYou: true } : {}),
+      // The session group it sits in (sessions an agent started here are
+      // grouped under that agent's session; the owner can group by hand).
+      ...sessionGroupField(row, groups),
     };
   }
 
@@ -1264,7 +1282,37 @@ export function createRemoteRelayDispatcher({
    * `lastActivityAt` of a session, from the relay's `sessionState` /
    * `sessionTasks`. A relay that predates them gives none.
    */
-  function sessionActivityFields(row) {
+  /**
+   * The console facts read_session adds to a task (`row` is the conversation
+   * payload): `taskId` for read_task_output, `output` whether there is any to
+   * read, and `health` (minutes since the last output, the quiet threshold,
+   * test-run counts) for a task with an output file.
+   */
+  function taskConsoleFields(row, id) {
+    const taskId = toText(id);
+    if (!taskId || !isPlainObject(row)) return {};
+    const live = (Array.isArray(row.backgroundTasks) ? row.backgroundTasks : []).find((task) => toText(task?.taskId) === taskId);
+    const ended = live ? null : (Array.isArray(row.endedBackgroundTasks) ? row.endedBackgroundTasks : []).find((task) => toText(task?.taskId) === taskId);
+    const task = live || ended;
+    if (!task) return {};
+    const kind = toText(task.outputKind) || (toText(task.outputPath) ? 'file' : 'none');
+    const health = isPlainObject(task.health) ? task.health : null;
+    const quietAfter = Number(row.taskStallMinutes) || null;
+    const minutes = live && health ? stallMinutes(health.lastOutputAt, now()) : null;
+    return {
+      taskId,
+      output: kind !== 'none',
+      ...(health ? {
+        health: {
+          ...(minutes !== null ? { minutesSinceOutput: minutes } : {}),
+          ...(quietAfter && minutes !== null ? { quiet: minutes >= quietAfter, quietAfterMinutes: quietAfter } : {}),
+          ...(isPlainObject(health.counts) ? { counts: { runner: toText(health.runner) || null, ...health.counts } } : {}),
+        },
+      } : {}),
+    };
+  }
+
+  function sessionActivityFields(row, { console: withConsole = false } = {}) {
     const state = toText(row?.sessionState);
     if (!SESSION_STATES.has(state)) return {};
     const tasks = (Array.isArray(row?.sessionTasks) ? row.sessionTasks : [])
@@ -1281,6 +1329,7 @@ export function createRemoteRelayDispatcher({
         ...(toText(task.summary) && toText(task.status) !== 'running' ? { summary: clipLine(task.summary, 200) } : {}),
         ...(task.endedAt ? { endedAt: task.endedAt } : {}),
         ...(toText(task.id) ? { id: toText(task.id) } : {}),
+        ...(withConsole ? taskConsoleFields(row, task.id) : {}),
       }));
     return {
       state,
@@ -1296,7 +1345,7 @@ export function createRemoteRelayDispatcher({
     // pages, all = the whole list page by page (only it honours the cursor).
     let cursor = null;
     if (scope === 'all' && args.cursor) {
-      cursor = decodeCursor(args.cursor, ['beforeConversationId', 'beforeUpdatedAt']);
+      cursor = decodeCursor(args.cursor, ['beforeConversationId', 'beforeUpdatedAt', 'beforeGroupId']);
       if (!cursor) throw invalidInput('cursor is not a nextCursor from list_sessions');
     }
     const workerIds = scope === 'active' ? await liveWorkerConversationIds(ctx) : null;
@@ -1305,6 +1354,7 @@ export function createRemoteRelayDispatcher({
       && (scope !== 'active' || row?.activeTurn === true || workerIds.has(toText(row?.id)) || isBusyState(row?.sessionState));
 
     const sessions = [];
+    const seen = new Set();
     let hasMore = false;
     let scanned = 0;
     for (let page = 0; page < (filtering ? LIST_SCAN_PAGES : 1); page += 1) {
@@ -1313,18 +1363,32 @@ export function createRemoteRelayDispatcher({
           limit: filtering ? LIST_PAGE_MAX : limit,
           beforeConversationId: cursor?.beforeConversationId,
           beforeUpdatedAt: cursor?.beforeUpdatedAt,
+          beforeGroupId: cursor?.beforeGroupId,
         },
       });
       const rows = Array.isArray(response?.conversations) ? response.conversations : [];
+      const groups = isPlainObject(response?.groups) ? response.groups : null;
       let consumed = 0;
       for (const row of rows) {
         consumed += 1;
-        if (keep(row)) sessions.push(mapSession(row, workerIds, ctx));
+        // A group served again whole (its cursor row vanished) repeats rows.
+        if (seen.has(toText(row?.id))) continue;
+        seen.add(toText(row?.id));
+        if (keep(row)) sessions.push(mapSession(row, workerIds, ctx, groups));
         if (sessions.length >= limit) break;
       }
       scanned += consumed;
       const last = rows[consumed - 1];
-      if (last) cursor = { beforeConversationId: toText(last.id), beforeUpdatedAt: toText(last.updatedAt) };
+      // The row's sort time (its group's newest row, `activityAt`) and its
+      // group, so the next page continues from the right place even if the
+      // row is archived or deleted before then.
+      if (last) {
+        cursor = {
+          beforeConversationId: toText(last.id),
+          beforeUpdatedAt: toText(last.activityAt) || toText(last.updatedAt),
+          ...(toText(last.groupId) ? { beforeGroupId: toText(last.groupId) } : {}),
+        };
+      }
       hasMore = consumed < rows.length || response?.pageInfo?.hasMore === true;
       if (sessions.length >= limit || !hasMore || !rows.length) break;
     }
@@ -1405,7 +1469,9 @@ export function createRemoteRelayDispatcher({
       if (!before) throw invalidInput('before is not an olderCursor from read_session');
     }
     const conversation = await call(ctx, 'GET', sessionPath(args.session), {
-      query: { limit: args.last, beforeMessageId: before?.beforeMessageId, beforeTimestamp: before?.beforeTimestamp },
+      // groupMembers: the session group's live members; the relay gives them
+      // to its own sessions only.
+      query: { limit: args.last, beforeMessageId: before?.beforeMessageId, beforeTimestamp: before?.beforeTimestamp, groupMembers: 1 },
     });
     const conversationId = toText(conversation?.id) || args.session;
     const pendingQuestions = await loadPendingQuestions(ctx, conversationId);
@@ -1425,6 +1491,23 @@ export function createRemoteRelayDispatcher({
     const runtime = isPlainObject(conversation?.runtimeSession) ? conversation.runtimeSession : {};
     const via = toText(conversation?.origin?.relayName);
     const inFlight = progressSnapshot(conversation?.inFlight);
+    // Its session group, with the other members and what each is doing.
+    const groupInfo = isPlainObject(conversation?.group) ? conversation.group : null;
+    const group = groupInfo && toText(groupInfo.id) ? {
+      id: toText(groupInfo.id),
+      name: toText(groupInfo.displayName) || toText(groupInfo.name) || null,
+      role: toText(groupInfo.role) === 'head' ? 'head' : 'member',
+      members: (Array.isArray(groupInfo.members) ? groupInfo.members : [])
+        .filter(isPlainObject)
+        .slice(0, 50)
+        .map((member) => ({
+          id: toText(member.id),
+          title: toText(member.title),
+          role: toText(member.role) === 'head' ? 'head' : 'member',
+          state: SESSION_STATES.has(toText(member.state)) ? toText(member.state) : 'idle',
+          ...(member.archived === true ? { archived: true } : {}),
+        })),
+    } : null;
     return {
       summary: `read_session → ${ctx.relay.name} session ${shortId(conversationId)}: ${messages.length} message${messages.length === 1 ? '' : 's'}${inFlight ? ', turn running' : ''}${pendingQuestions.length ? `, ${pendingQuestions.length} question${pendingQuestions.length === 1 ? '' : 's'} pending` : ''}`,
       session: {
@@ -1436,8 +1519,9 @@ export function createRemoteRelayDispatcher({
         cwd: toText(conversation?.currentWorkspaceRootPath) || null,
         archived: conversation?.archived === true,
         active: conversation?.activeTurn === true || isBusyState(conversation?.sessionState),
-        ...sessionActivityFields(conversation),
+        ...sessionActivityFields(conversation, { console: true }),
         ...(via ? { via } : {}),
+        ...(group ? { group } : {}),
         openUrl: remoteConversationUrl(ctx.relay.url, conversationId) || null,
       },
       messages,
@@ -1448,6 +1532,101 @@ export function createRemoteRelayDispatcher({
     };
   }
 
+  /**
+   * read_task_output: the end of a background shell or Monitor task's
+   * output (GET …/background-task/:taskId/output on the target relay, which
+   * scrubs it), as plain lines without colours, at most `lines` lines and
+   * 32 KB; minutes since its last output; test-run counts when it is one.
+   */
+  async function readTaskOutput(ctx, args) {
+    let answer;
+    try {
+      answer = await call(ctx, 'GET', sessionPath(args.session, `/background-task/${encodeURIComponent(args.task_id)}/output`), {
+        query: { lines: args.lines },
+      });
+    } catch (error) {
+      const status = Number(error?.status) || null;
+      if (isRemoteRelayError(error) && (status === 404 || toText(error.code) === REMOTE_RELAY_ERROR_CODES.notFound)) {
+        const body = isPlainObject(error.remoteBody) ? error.remoteBody : {};
+        if (toText(body.code) === 'task-not-found') {
+          throw new DispatchFailure(404, REMOTE_RELAY_ERROR_CODES.notFound,
+            `Task ${args.task_id} is not running in session ${args.session} on relay "${ctx.relay.name}" and did not end there within the last hour; read_session lists the session's tasks.`);
+        }
+        if (!/conversation not found/i.test(toText(body.error))) {
+          throw new DispatchFailure(400, REMOTE_RELAY_ERROR_CODES.unsupported,
+            `Relay "${ctx.relay.name}" cannot show background task output (it runs an older OAR version).`);
+        }
+      }
+      throw error;
+    }
+    const model = Array.isArray(answer?.lines) ? answer.lines : [];
+    const task = isPlainObject(answer?.task) ? answer.task : {};
+    const ended = answer?.ended === true;
+    // Plain text, a repeat folded as ×N; cleaned again, whatever the other
+    // side did.
+    const rendered = model.map((line) => {
+      const text = stripSgr(cleanTaskOutput(String(line?.text ?? '')));
+      const count = Number(line?.count) > 1 ? Number(line.count) : 1;
+      return count > 1 ? `${text}  [×${count}]` : text;
+    });
+    let tail = rendered.slice(-args.lines);
+    let cut = tail.length < rendered.length;
+    let bytes = 0;
+    let keepFrom = tail.length;
+    for (let index = tail.length - 1; index >= 0; index -= 1) {
+      bytes += Buffer.byteLength(tail[index], 'utf8') + 1;
+      if (bytes > REMOTE_RELAY_LIMITS.taskOutputBytesMax) break;
+      keepFrom = index;
+    }
+    if (keepFrom > 0) {
+      tail = tail.slice(keepFrom);
+      cut = true;
+    }
+    const health = isPlainObject(answer?.health) ? answer.health : null;
+    const lastOutputAt = Number(health?.lastOutputAt) || Number(answer?.mtime) || null;
+    const minutes = !ended && lastOutputAt ? stallMinutes(lastOutputAt, now()) : null;
+    const quietAfter = Number(answer?.taskStallMinutes) || null;
+    let counts = null;
+    if (isPlainObject(health?.counts)) {
+      counts = { runner: toText(health.runner) || null, ...health.counts, final: health.final === true };
+    } else {
+      const parsed = parseRunnerSummary(model);
+      if (parsed) counts = { runner: parsed.runner, passed: parsed.passed, failed: parsed.failed, skipped: parsed.skipped, final: parsed.final };
+    }
+    const kind = toText(answer?.kind) || 'file';
+    let note = null;
+    if (kind === 'none') note = toText(answer?.message) || 'Output is not available for this provider.';
+    else if (answer?.pending) note = 'The session\'s worker was asked for the output; call again in a few seconds.';
+    else if (answer?.unavailable) note = 'The output file is not there any more (the provider cleaned it up).';
+    else if (kind === 'snapshot') note = 'Only the end of this task\'s output is available (its provider keeps no file).';
+    const status = ended ? (toText(answer?.status) || 'unknown') : 'running';
+    const exitCode = Number.isInteger(answer?.exitCode) ? answer.exitCode : null;
+    const parts = [`${tail.length} line${tail.length === 1 ? '' : 's'}`, ended ? `ended (${status}${exitCode !== null ? `, exit ${exitCode}` : ''})` : 'running'];
+    if (minutes !== null) parts.push(`last output ${minutes} min ago`);
+    if (counts) parts.push(`${counts.passed} passed, ${counts.failed} failed`);
+    return {
+      summary: `read_task_output → ${ctx.relay.name} session ${shortId(args.session)} task ${shortId(args.task_id)}: ${parts.join(', ')}`,
+      task: {
+        id: args.task_id,
+        description: toText(task.description),
+        type: toText(task.taskType) || null,
+        startedAt: task.startedAt || null,
+        status,
+        exitCode,
+        ...(task.endedAt ? { endedAt: task.endedAt } : {}),
+      },
+      stall: minutes === null ? null : {
+        minutes,
+        since: new Date(lastOutputAt).toISOString(),
+        ...(quietAfter ? { quiet: minutes >= quietAfter, quietAfterMinutes: quietAfter } : {}),
+      },
+      counts,
+      tail,
+      truncated: cut || answer?.hasMoreBefore === true,
+      ...(note ? { note } : {}),
+    };
+  }
+
   function outcomeSummary(action, ctx, outcome) {
     const questions = Array.isArray(outcome.pendingQuestions) ? outcome.pendingQuestions.length : 0;
     return `${action} → ${ctx.relay.name} session ${shortId(outcome.session)}: ${outcome.status}`
@@ -2220,6 +2399,7 @@ export function createRemoteRelayDispatcher({
     usage: usageAction,
     list_sessions: listSessions,
     read_session: readSession,
+    read_task_output: readTaskOutput,
     wait: waitAction,
     send,
     create_session: createSession,

package/server/services/request-boundary.mjs

@@ -0,0 +1,183 @@
+'use strict';
+
+// Where a request came from, as far as the relay can tell.
+//
+// "Truly local" is the boundary for the few things only a process on the
+// relay's own machine may do (run an image operation, open a session-worker
+// socket): the TCP peer is loopback AND nothing in front of the relay touched
+// the request. A same-host reverse proxy (Caddy, nginx), a hand-run
+// cloudflared and the built-in tunnel all connect from 127.0.0.1 too, so the
+// peer alone proves nothing; what tells them apart is what they add: an edge
+// marker (`cf-ray`, or a configured one) or a forwarding header. Local workers
+// and agent tools call the relay over 127.0.0.1 and send none of these.
+//
+// A forwarder that adds no header at all (an SSH reverse tunnel, a bare TCP
+// proxy) cannot be told apart from a local process; the access token is then
+// the only boundary, as it is for every other route.
+
+// Cloudflare's edge stamps `cf-ray` on every proxied request and a remote
+// client cannot strip it.
+export const DEFAULT_TUNNEL_MARKER_HEADERS = Object.freeze(['cf-ray']);
+
+// Headers a proxy adds to say who it forwards for. Read here only as a trace
+// that a proxy was involved, never as an address.
+export const FORWARDING_HEADERS = Object.freeze(['x-forwarded-for', 'forwarded', 'x-real-ip']);
+
+function normalizeHeaderName(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function headerNamesFrom(source) {
+  if (Array.isArray(source)) return source;
+  if (source === undefined || source === null) return [];
+  return String(source).split(',');
+}
+
+/**
+ * The marker headers to look for: `cf-ray` always, plus every name from every
+ * source given (an array or a comma-separated string). Sources are merged,
+ * none replaces another, so `tunnelMarkerHeaders: []` in the config does not
+ * switch off COPILOT_TUNNEL_MARKER_HEADERS.
+ */
+export function resolveTunnelMarkerHeaders(...sources) {
+  const names = [...DEFAULT_TUNNEL_MARKER_HEADERS];
+  for (const source of sources) {
+    for (const entry of headerNamesFrom(source)) {
+      const name = normalizeHeaderName(entry);
+      if (name && !names.includes(name)) names.push(name);
+    }
+  }
+  return names;
+}
+
+/** 127.0.0.0/8 and ::1, plain or IPv4-mapped. */
+export function isLoopbackAddress(value) {
+  let text = String(value || '').trim().toLowerCase();
+  if (!text) return false;
+  if (text === '::1' || text === '0:0:0:0:0:0:0:1') return true;
+  if (text.startsWith('::ffff:')) text = text.slice(7);
+  if (text === '7f00:1') return true;
+  return /^127(?:\.\d{1,3}){3}$/.test(text);
+}
+
+function headerPresent(headers, name) {
+  const value = headers?.[name];
+  if (Array.isArray(value)) return value.some((entry) => String(entry || '').trim());
+  return typeof value === 'string' ? !!value.trim() : !!value;
+}
+
+function peerAddressOf(req) {
+  return req?.socket?.remoteAddress || req?.connection?.remoteAddress || '';
+}
+
+/**
+ * `markerHeaders`: names as resolveTunnelMarkerHeaders returns them (the
+ * default `cf-ray` is added if missing).
+ */
+export function createLocalRequestCheck({ markerHeaders = DEFAULT_TUNNEL_MARKER_HEADERS } = {}) {
+  const markers = resolveTunnelMarkerHeaders(markerHeaders);
+
+  function matchedMarkerHeader(headers) {
+    for (const name of markers) {
+      if (headerPresent(headers, name)) return name;
+    }
+    return null;
+  }
+
+  function matchedForwardingHeader(headers) {
+    for (const name of FORWARDING_HEADERS) {
+      if (headerPresent(headers, name)) return name;
+    }
+    return null;
+  }
+
+  /**
+   * Why a request is not truly local: `{ reason: 'peer' | 'marker' |
+   * 'forwarded', header }`, or null when it is.
+   */
+  function explain(req) {
+    if (!isLoopbackAddress(peerAddressOf(req))) return { reason: 'peer', header: null };
+    const marker = matchedMarkerHeader(req?.headers);
+    if (marker) return { reason: 'marker', header: marker };
+    const forwarded = matchedForwardingHeader(req?.headers);
+    if (forwarded) return { reason: 'forwarded', header: forwarded };
+    return null;
+  }
+
+  function isTrulyLocal(req) {
+    return explain(req) === null;
+  }
+
+  return {
+    markerHeaders: markers,
+    matchedMarkerHeader,
+    explain,
+    isTrulyLocal,
+  };
+}
+
+function trustsPeer(req) {
+  const trust = typeof req?.app?.get === 'function' ? req.app.get('trust proxy fn') : null;
+  return typeof trust === 'function' && trust(peerAddressOf(req), 0) === true;
+}
+
+function firstListEntry(value) {
+  return String(Array.isArray(value) ? value[0] : (value || '')).split(',')[0].trim();
+}
+
+/**
+ * The host (with port) the client addressed: X-Forwarded-Host when the
+ * immediate peer is a trusted proxy (Express `trust proxy`), else Host. A
+ * direct client cannot forge it. Express's own `req.hostname` drops the port,
+ * which a LAN address needs.
+ */
+export function requestHostOf(req) {
+  if (trustsPeer(req)) {
+    const forwardedHost = firstListEntry(req?.headers?.['x-forwarded-host']);
+    if (forwardedHost) return forwardedHost;
+  }
+  return firstListEntry(req?.headers?.host);
+}
+
+/** An Express-style view of a raw request (a socket.io handshake), so `ip`, `protocol` and the trust checks follow `trust proxy`. */
+export function expressRequestView(app, rawReq) {
+  const view = Object.create(app.request);
+  view.headers = rawReq?.headers || {};
+  view.socket = rawReq?.socket || rawReq?.connection || null;
+  view.connection = view.socket;
+  view.method = rawReq?.method;
+  view.url = rawReq?.url;
+  return view;
+}
+
+function normalizedHost(protocol, host) {
+  try {
+    return new URL(`${protocol}//${host}`).host.toLowerCase();
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Same-origin check for a browser handshake. No Origin header (a non-browser
+ * client) passes; otherwise the Origin's host must be the host the request
+ * was addressed to (see requestHostOf), or be listed in `allowedOrigins`.
+ */
+export function isSameOriginRequest(req, { allowedOrigins = [] } = {}) {
+  const origin = firstListEntry(req?.headers?.origin);
+  if (!origin) return true;
+  let parsed;
+  try {
+    parsed = new URL(origin);
+  } catch {
+    return false;
+  }
+  if (parsed.origin === 'null') return false;
+  const allowed = (Array.isArray(allowedOrigins) ? allowedOrigins : headerNamesFrom(allowedOrigins))
+    .map((entry) => String(entry || '').trim().replace(/\/+$/, '').toLowerCase())
+    .filter(Boolean);
+  if (allowed.includes(parsed.origin.toLowerCase())) return true;
+  const host = requestHostOf(req);
+  if (!host) return false;
+  return normalizedHost(parsed.protocol, host) === parsed.host.toLowerCase();
+}