@oar-sh/oar 0.9.4 → 0.9.6

package/server/services/process-list-service.mjs

@@ -0,0 +1,122 @@
+'use strict';
+
+// The process table, read the way each platform allows, for the tree watch in
+// shared/worker-runtime/process-tree.mjs. Every entry carries the time the
+// process was started: that is what tells it from a later process that was
+// given its pid.
+//
+//  - Linux reads `/proc/<pid>/stat`, which needs no process and takes about
+//    3 ms for 160 processes (measured 2026-09-29). The start time is field 22,
+//    in clock ticks since boot.
+//  - Windows asks PowerShell, through the list the relay's process inspector
+//    already reads. It takes about a second, so it is never polled.
+//  - Every other platform asks `ps`, whose start time has a resolution of one
+//    second.
+
+import fs from 'fs';
+import { execFile } from 'child_process';
+
+import { createSessionWorkerProcessInspector } from './session-worker-process-service.mjs';
+
+const PS_TIMEOUT_MS = 10_000;
+
+/**
+ * One `/proc/<pid>/stat`. The name (field 2) is in parentheses and may hold
+ * spaces and parentheses of its own, so the fields after it are counted from
+ * the LAST closing one. A process that has ended and only waits to be
+ * collected (`Z`, `X`) is not running any more.
+ */
+export function parseProcStat(text) {
+  const raw = String(text || '');
+  const open = raw.indexOf('(');
+  const close = raw.lastIndexOf(')');
+  if (open < 1 || close < open) return null;
+  const processId = Number.parseInt(raw.slice(0, open), 10);
+  const fields = raw.slice(close + 2).trim().split(/\s+/);
+  const state = fields[0] || '';
+  const createdAt = Number(fields[19]);
+  if (!(processId > 0) || state === 'Z' || state === 'X' || !(createdAt > 0)) return null;
+  return {
+    processId,
+    parentProcessId: Number.parseInt(fields[1], 10) || 0,
+    name: raw.slice(open + 1, close),
+    createdAt,
+    // The runtime starts a command in a session of its own.
+    sessionLeader: Number.parseInt(fields[3], 10) === processId,
+  };
+}
+
+/** One line of `ps -o pid=,ppid=,stat=,lstart=,args=`. */
+export function parsePsLine(line) {
+  const match = String(line || '').match(
+    /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(\w{3}\s+\w{3}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2}\s+\d{4})\s*(.*)$/,
+  );
+  if (!match) return null;
+  const createdAt = Date.parse(match[4]);
+  if (/^[ZX]/.test(match[3]) || !(createdAt > 0)) return null;
+  return {
+    processId: Number.parseInt(match[1], 10),
+    parentProcessId: Number.parseInt(match[2], 10) || 0,
+    createdAt,
+    commandLine: match[5],
+  };
+}
+
+export function createProcessLister({
+  platform = process.platform,
+  readdirSyncImpl = fs.readdirSync,
+  readFileSyncImpl = fs.readFileSync,
+  execFileImpl = execFile,
+  inspector = null,
+} = {}) {
+  if (platform === 'win32') {
+    const windows = inspector || createSessionWorkerProcessInspector({ platform, execFileImpl });
+    return {
+      // A child keeps the pid of its parent after the parent has ended.
+      orphansKeepParent: true,
+      list: () => windows.readWindowsProcessSnapshot(),
+    };
+  }
+
+  if (platform === 'linux') {
+    const read = (pid) => {
+      try {
+        return parseProcStat(readFileSyncImpl(`/proc/${pid}/stat`, 'utf8'));
+      } catch {
+        // It ended between the directory listing and the read.
+        return null;
+      }
+    };
+    return {
+      orphansKeepParent: false,
+      list: () => readdirSyncImpl('/proc')
+        .filter((name) => /^\d+$/.test(String(name)))
+        .map((name) => read(name))
+        .filter(Boolean),
+      read,
+      describe(pid) {
+        try {
+          return String(readFileSyncImpl(`/proc/${pid}/cmdline`, 'utf8')).replace(/\0/g, ' ').trim();
+        } catch {
+          return '';
+        }
+      },
+    };
+  }
+
+  return {
+    orphansKeepParent: false,
+    list: () => new Promise((resolve, reject) => {
+      execFileImpl(
+        'ps',
+        ['-axww', '-o', 'pid=,ppid=,stat=,lstart=,args='],
+        // `lstart` is parsed as a date: keep it in the one language that is.
+        { timeout: PS_TIMEOUT_MS, maxBuffer: 64 * 1024 * 1024, env: { ...process.env, LC_ALL: 'C' } },
+        (error, stdout) => {
+          if (error) reject(error);
+          else resolve(String(stdout || '').split(/\r?\n/).map(parsePsLine).filter(Boolean));
+        },
+      );
+    }),
+  };
+}

package/server/services/relay-console-log.mjs

@@ -0,0 +1,199 @@
+'use strict';
+
+// The relay's console, kept in a file.
+//
+// The relay writes what it does to its console: a terminal, a tmux pane, a
+// service manager's journal or nothing at all, depending on how it was
+// started. After an incident or a restart that output is what one wants to
+// read, so the runtime copies it into `<log dir>/relay-console.log`, with a
+// time stamp per line and a size limit.
+//
+// The copy is taken from the console's methods rather than from stdout: the
+// terminal console (tty-console) redraws its prompt on stdout, and none of
+// that belongs in a log.
+
+import fs from 'fs';
+import path from 'path';
+import { format } from 'util';
+
+export const RELAY_CONSOLE_LOG_FILE = 'relay-console.log';
+export const RELAY_CONSOLE_LOG_DISABLE_ENV = 'OAR_NO_CONSOLE_LOG';
+
+const DEFAULT_MAX_BYTES = 5 * 1024 * 1024;
+const DEFAULT_KEEP = 3;
+const LEVELS = Object.freeze(['log', 'info', 'warn', 'error', 'debug']);
+const ANSI_STYLE_PATTERN = /\u001b\[[0-9;]*m/g;
+// A token in a URL, whatever its value: the page is opened with `?token=`.
+const TOKEN_PARAM_PATTERN = /([?&]token=)[^&\s"'<>]+/gi;
+const SECRET_MIN_LENGTH = 6;
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Where the console log goes: the log directory the environment names, else
+ * `logs` under a data directory the environment names (a relay with its own
+ * data keeps its own log), else `logs` next to the server.
+ */
+export function resolveRelayConsoleLogPath({ env = process.env, serverDir, pathImpl = path } = {}) {
+  const logDir = String(env?.COPILOT_WEB_RELAY_LOG_DIR || '').trim();
+  const dataDir = String(env?.COPILOT_WEB_RELAY_DATA_DIR || '').trim();
+  const dir = logDir
+    || (dataDir ? pathImpl.join(dataDir, 'logs') : pathImpl.join(String(serverDir || process.cwd()), 'logs'));
+  return pathImpl.join(pathImpl.resolve(dir), RELAY_CONSOLE_LOG_FILE);
+}
+
+/**
+ * Copies what the relay writes to its console into `logPath`. Returns null
+ * when it is switched off or the file cannot be opened: a log problem must
+ * never stop the relay.
+ *
+ * `{ logPath, setSecrets(values), rewrap(), write(level, text), uninstall() }`:
+ * `setSecrets` names values that are never written (the auth token, once the
+ * config is read), or a function that returns them, asked at every write so
+ * a token that changes is covered; `rewrap` puts the copy in front again
+ * after something else replaced the console's methods.
+ */
+export function installRelayConsoleLog({
+  logPath,
+  env = process.env,
+  consoleImpl = console,
+  processImpl = process,
+  fsImpl = fs,
+  now = () => new Date(),
+  maxBytes = DEFAULT_MAX_BYTES,
+  keep = DEFAULT_KEEP,
+} = {}) {
+  if (String(env?.[RELAY_CONSOLE_LOG_DISABLE_ENV] || '').trim() === '1') return null;
+  const target = String(logPath || '').trim();
+  if (!target) return null;
+
+  let fd = null;
+  let size = 0;
+  let secretSource = () => [];
+  let secretKey = '';
+  let secretPattern = null;
+
+  function open() {
+    fsImpl.mkdirSync(path.dirname(target), { recursive: true });
+    fd = fsImpl.openSync(target, 'a');
+    try {
+      size = Number(fsImpl.fstatSync(fd).size) || 0;
+    } catch {
+      size = 0;
+    }
+  }
+
+  function close() {
+    if (fd === null) return;
+    try { fsImpl.closeSync(fd); } catch {}
+    fd = null;
+  }
+
+  // relay-console.log → .1 → .2 …; the oldest of `keep` is dropped.
+  function rotate() {
+    close();
+    try {
+      for (let index = keep; index >= 1; index -= 1) {
+        const from = index === 1 ? target : `${target}.${index - 1}`;
+        const to = `${target}.${index}`;
+        if (!fsImpl.existsSync(from)) continue;
+        try { fsImpl.rmSync(to, { force: true }); } catch {}
+        fsImpl.renameSync(from, to);
+      }
+    } catch {
+      // A file that cannot be moved (held open elsewhere) is written on.
+    }
+    open();
+  }
+
+  function currentSecretPattern() {
+    let values = [];
+    try {
+      values = secretSource() || [];
+    } catch {}
+    const secrets = (Array.isArray(values) ? values : [values])
+      .map((value) => String(value ?? '').trim())
+      .filter((value) => value.length >= SECRET_MIN_LENGTH);
+    const key = secrets.join('\n');
+    if (key !== secretKey) {
+      secretKey = key;
+      secretPattern = secrets.length ? new RegExp(secrets.map(escapeRegExp).join('|'), 'g') : null;
+    }
+    return secretPattern;
+  }
+
+  function scrub(text) {
+    const out = String(text).replace(ANSI_STYLE_PATTERN, '').replace(TOKEN_PARAM_PATTERN, '$1[token]');
+    const secrets = currentSecretPattern();
+    return secrets ? out.replace(secrets, '[token]') : out;
+  }
+
+  // Synchronous on purpose: the last lines before an exit are the ones an
+  // incident needs.
+  function write(level, text) {
+    if (fd === null) return;
+    try {
+      const stamp = now().toISOString();
+      const tag = level === 'log' ? '' : `${String(level).toUpperCase()} `;
+      const lines = scrub(text).split(/\r?\n/).map((line) => `${stamp} ${tag}${line}\n`).join('');
+      if (size > 0 && size + Buffer.byteLength(lines) > maxBytes) rotate();
+      if (fd === null) return;
+      size += fsImpl.writeSync(fd, lines);
+    } catch {
+      // A file that stopped taking writes (disk full, handle gone) is given up.
+      close();
+    }
+  }
+
+  try {
+    open();
+    if (size > maxBytes) rotate();
+  } catch {
+    close();
+    return null;
+  }
+
+  const wrapped = new Map();
+  function wrap() {
+    for (const level of LEVELS) {
+      const current = consoleImpl[level];
+      if (typeof current !== 'function' || current.relayConsoleLog === true) continue;
+      const copy = function relayConsoleCopy(...args) {
+        try {
+          write(level, format(...args));
+        } catch {}
+        return current.apply(this, args);
+      };
+      copy.relayConsoleLog = true;
+      copy.inner = current;
+      consoleImpl[level] = copy;
+      wrapped.set(level, copy);
+    }
+  }
+  wrap();
+
+  // Without a handler Node prints an uncaught error natively, past the console.
+  const onUncaught = (error, origin) => {
+    write('error', `${origin || 'uncaughtException'}: ${error?.stack || error?.message || error}`);
+  };
+  processImpl.on?.('uncaughtExceptionMonitor', onUncaught);
+
+  return {
+    logPath: target,
+    write,
+    rewrap: wrap,
+    setSecrets(values = []) {
+      secretSource = typeof values === 'function' ? values : () => values;
+    },
+    uninstall() {
+      for (const [level, copy] of wrapped) {
+        if (consoleImpl[level] === copy) consoleImpl[level] = copy.inner;
+      }
+      wrapped.clear();
+      processImpl.off?.('uncaughtExceptionMonitor', onUncaught);
+      close();
+    },
+  };
+}

package/server/services/remote-relay-caller-context.mjs

@@ -120,11 +120,16 @@ function describeRemoteTurn(action, args, caller) {
  * run, then the prompt (or the answer) it wants to send, so the user decides
  * on the actual words. `caller` is the calling session's context.
  */
-export function formatRemoteRelayApprovalPrompt({ relay, action, args = {}, caller = null } = {}) {
+export function formatRemoteRelayApprovalPrompt({ relay, action, args = {}, caller = null, agentPrompts = 0 } = {}) {
   const name = toText(relay?.name) || 'a remote relay';
   const verb = APPROVAL_VERBS[action] || toText(action).replace(/_/g, ' ') || 'act';
   const target = args.session ? ` (session ${shortId(args.session)})` : '';
-  const lines = [`Allow the agent to ${verb} on relay "${name}"${target}?`];
+  const lines = [];
+  // The loop guard's card: agents that prompt each other without the user.
+  if (agentPrompts > 0) {
+    lines.push(`The agent has sent ${agentPrompts} prompts to agents on other relays since your last message. Let it go on?`);
+  }
+  lines.push(`Allow the agent to ${verb} on relay "${name}"${target}?`);
   if (action === 'send' || action === 'create_session') {
     const details = describeRemoteTurn(action, args, caller);
     if (details) lines.push(details);
@@ -155,10 +160,12 @@ export function createRemoteRelayCallerContext({
   questionTimeoutMs = DEFAULT_QUESTION_TIMEOUT_MS,
 } = {}) {
   const questionStatements = questions || createQuestionRepository(db);
-  const getConversation = db.prepare(`SELECT id, title, preferred_relay_mode, preferred_model FROM conversations WHERE id = ?`);
+  const getConversation = db.prepare(`
+    SELECT id, title, preferred_relay_mode, preferred_model, preferred_reasoning_effort FROM conversations WHERE id = ?
+  `);
   const getRuntimeSession = db.prepare(`SELECT provider_type, provider_model, model FROM runtime_sessions WHERE conversation_id = ?`);
   const listProcessingRows = db.prepare(`
-    SELECT id, kind, relay_mode, model, attempt_id, owner_sdk_session_id, timestamp, processing_at
+    SELECT id, kind, relay_mode, model, reasoning_effort, attempt_id, owner_sdk_session_id, timestamp, processing_at
     FROM queue
     WHERE conversation_id = ? AND status = 'processing'
     ORDER BY COALESCE(processing_at, timestamp) ASC
@@ -196,35 +203,44 @@ export function createRemoteRelayCallerContext({
     return rows.find((row) => row.id === liveId) || rows[0];
   }
 
-  function originHops(messageId) {
-    const origin = messageId ? repository?.getMessageOrigin?.(messageId) : null;
+  function messageOrigin(messageId) {
+    return (messageId ? repository?.getMessageOrigin?.(messageId) : null) || null;
+  }
+
+  function originHops(origin) {
     const hops = Number(origin?.hops);
     return Number.isInteger(hops) && hops >= 0 ? hops : 0;
   }
 
   /**
-   * A turn's hops: those of its own user message, or for a continuation row
-   * (no message of its own) those of the latest user message before it, the
-   * turn whose background work it continues.
+   * Where a turn's prompt came from (null for a human's): the origin of its
+   * own user message, or for a continuation row (no message of its own) that
+   * of the latest user message before it, the turn whose background work it
+   * continues.
    */
-  function rowHops(conversationId, row) {
-    if (toText(row.kind).toLowerCase() !== 'continuation') return originHops(row.id);
+  function rowOrigin(conversationId, row) {
+    if (toText(row.kind).toLowerCase() !== 'continuation') return messageOrigin(row.id);
     const at = toText(row.timestamp) || toText(row.processing_at);
     const message = at
       ? getLatestUserMessageAtOrBefore.get(conversationId, at)
       : getLatestUserMessage.get(conversationId);
-    return originHops(message?.id);
+    return messageOrigin(message?.id);
   }
 
   /**
-   * `{ conversationId, title, provider, model, mode, processingRowId,
-   * attemptId, userMessageId, hops }` for the conversation making the call.
+   * `{ conversationId, title, provider, model, effort, mode, processingRowId,
+   * attemptId, userMessageId, hops, originRelayIds }` for the conversation
+   * making the call.
+   * `effort` is the reasoning effort of the live turn, else the one the
+   * conversation prefers ('' when neither is known).
    * `hops` is how many relays the current turn's prompt already crossed: 0
    * for a human's message. A steered message folded into the live turn is
    * part of what the agent is acting on, so the highest count among the
    * conversation's processing rows wins (a background continuation counts as
    * the turn it continues); without a turn (an off-turn call) the latest user
    * message decides.
+   * `originRelayIds` are the relays (their instance ids) those prompts came
+   * from: empty when the agent acts on the user's words alone.
    */
   function getCallerContext(conversationId) {
     const id = toText(conversationId);
@@ -232,19 +248,23 @@ export function createRemoteRelayCallerContext({
     const runtime = getRuntimeSession.get(id) || null;
     const rows = listProcessingRows.all(id);
     const live = liveTurnRow(id, rows);
-    const hops = rows.length
-      ? Math.max(...rows.map((row) => rowHops(id, row)))
-      : originHops(getLatestUserMessage.get(id)?.id);
+    const origins = (rows.length
+      ? rows.map((row) => rowOrigin(id, row))
+      : [messageOrigin(getLatestUserMessage.get(id)?.id)]).filter(Boolean);
+    const hops = Math.max(0, ...origins.map(originHops));
+    const originRelayIds = [...new Set(origins.map((origin) => toText(origin.relayId)))];
     return {
       conversationId: id,
       title: toText(conversation?.title),
       provider: toText(runtime?.provider_type).toLowerCase() || 'github',
       model: toText(live?.model) || toText(runtime?.provider_model) || toText(runtime?.model) || toText(conversation?.preferred_model) || '',
+      effort: (toText(live?.reasoning_effort) || toText(conversation?.preferred_reasoning_effort)).toLowerCase(),
       mode: normalizeMode(live?.relay_mode || conversation?.preferred_relay_mode),
       processingRowId: live?.id || null,
       attemptId: toText(live?.attempt_id) || null,
       userMessageId: live?.id || null,
       hops,
+      originRelayIds,
     };
   }
 
@@ -265,8 +285,11 @@ export function createRemoteRelayCallerContext({
    * denied, timed out, cancelled with the turn, or no turn to ask on (fails
    * closed with REMOTE_RELAY_NO_ACTIVE_TURN). Waits as long as the question
    * lives (8 h by default); `signal` withdraws the card early.
+   * `agentPrompts` (the loop guard) is how many prompts the agent has sent to
+   * other relays' agents since the user last wrote; the card then asks for
+   * that, in any relay mode.
    */
-  async function requestApproval({ conversationId, callerContext, relay, action, args = {}, signal } = {}) {
+  async function requestApproval({ conversationId, callerContext, relay, action, args = {}, signal, agentPrompts = 0 } = {}) {
     const rowId = toText(callerContext?.processingRowId);
     const row = rowId ? getQueueRow.get(rowId) : null;
     if (!row || row.status !== 'processing') {
@@ -280,10 +303,12 @@ export function createRemoteRelayCallerContext({
     const createdAt = now().toISOString();
     const questionId = String(uuid());
     const relayMode = normalizeMode(row.relay_mode);
-    const prompt = formatRemoteRelayApprovalPrompt({ relay, action, args, caller: callerContext });
+    const prompt = formatRemoteRelayApprovalPrompt({ relay, action, args, caller: callerContext, agentPrompts });
     const context = sanitizeRelayQuestionContext({
       source: REMOTE_RELAY_APPROVAL_SOURCE,
-      rationale: `Write actions on other relays need approval in ${relayMode} mode.`,
+      rationale: agentPrompts > 0
+        ? 'Agents on different relays that keep prompting each other need your go from time to time.'
+        : `Write actions on other relays need approval in ${relayMode} mode.`,
       queueMessageId: row.id,
       conversationId: toText(conversationId) || row.conversation_id,
       relayMode,