@oar-sh/oar 0.9.5 → 0.9.7

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

@@ -33,6 +33,8 @@ import { sanitizeRelayQuestionContext } from './relay-question-context.mjs';
 
 const LOG_PREFIX = '[remote-relays]';
 const APPROVAL_HEADER = 'Remote relay';
+// The once-per-conversation card for sessions an agent starts on this relay.
+const LOCAL_SESSIONS_HEADER = 'Agent sessions';
 const APPROVAL_ALLOW = 'Allow';
 const APPROVAL_DENY = 'Deny';
 const EXCERPT_MAX = 200;
@@ -115,16 +117,45 @@ function describeRemoteTurn(action, args, caller) {
   return parts.join(' · ');
 }
 
+/**
+ * What a session an agent starts on this relay works on, for the card: the
+ * repository (and branch) of a Claude Cloud session, else the folder, else
+ * the relay's default folder.
+ */
+function describeLocalSessionTarget(args) {
+  const repo = toText(args.repo).replace(/^https?:\/\/(?:www\.)?github\.com\//i, '');
+  if (repo) return toText(args.branch) ? `${excerpt(repo)}, branch ${excerpt(args.branch)}` : excerpt(repo);
+  return toText(args.cwd) ? excerpt(args.cwd) : 'the default folder';
+}
+
 /**
  * The card text: what the agent wants to do where, how the remote turn would
  * 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.
+ *
+ * `localSessions` is the once-per-conversation card of the local target: the
+ * agent wants to start sessions on this relay itself. Allowing it covers the
+ * later ones of that conversation, so the card says what they cost.
  */
-export function formatRemoteRelayApprovalPrompt({ relay, action, args = {}, caller = null } = {}) {
+export function formatRemoteRelayApprovalPrompt({ relay, action, args = {}, caller = null, agentPrompts = 0, localSessions = false } = {}) {
+  const local = relay?.local === true;
   const name = toText(relay?.name) || 'a remote relay';
+  const where = local ? 'this relay' : `relay "${name}"`;
   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 ${local ? 'other agents' : 'agents on other relays'} since your last message. Let it go on?`);
+  }
+  if (localSessions) {
+    const requested = toText(args.provider).toLowerCase();
+    const callerProvider = toText(caller?.provider).toLowerCase();
+    const provider = requested || (REMOTE_RELAY_PROVIDERS.includes(callerProvider) ? callerProvider : 'github');
+    lines.push(`This agent wants to start sessions on this relay (${provider}, ${describeLocalSessionTarget(args)}). Sessions it starts use this relay's accounts.`);
+  } else {
+    lines.push(`Allow the agent to ${verb} on ${where}${target}?`);
+  }
   if (action === 'send' || action === 'create_session') {
     const details = describeRemoteTurn(action, args, caller);
     if (details) lines.push(details);
@@ -198,29 +229,34 @@ 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, effort, mode, processingRowId,
-   * attemptId, userMessageId, hops }` for the conversation making the call.
+   * 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
@@ -229,6 +265,8 @@ export function createRemoteRelayCallerContext({
    * 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);
@@ -236,9 +274,11 @@ 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),
@@ -250,6 +290,7 @@ export function createRemoteRelayCallerContext({
       attemptId: toText(live?.attempt_id) || null,
       userMessageId: live?.id || null,
       hops,
+      originRelayIds,
     };
   }
 
@@ -270,29 +311,47 @@ 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.
+   * `localSessions` makes it the card for starting sessions on this relay
+   * itself, asked once per conversation (the dispatcher remembers the Allow).
    */
-  async function requestApproval({ conversationId, callerContext, relay, action, args = {}, signal } = {}) {
+  async function requestApproval({ conversationId, callerContext, relay, action, args = {}, signal, agentPrompts = 0, localSessions = false } = {}) {
     const rowId = toText(callerContext?.processingRowId);
     const row = rowId ? getQueueRow.get(rowId) : null;
     if (!row || row.status !== 'processing') {
       return {
         approved: false,
         code: REMOTE_RELAY_ERROR_CODES.noTurn,
-        error: 'This write action needs the user\'s approval, but the conversation has no running turn to ask on.',
+        error: localSessions
+          ? 'Starting sessions on this relay needs the user\'s approval once per conversation, but the conversation has no running turn to ask on.'
+          : 'This write action needs the user\'s approval, but the conversation has no running turn to ask on.',
       };
     }
 
     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, localSessions });
+    const local = relay?.local === true;
+    let rationale = `Write actions on ${local ? 'other sessions of this relay' : 'other relays'} need approval in ${relayMode} mode.`;
+    if (agentPrompts > 0) {
+      rationale = local
+        ? 'Agents that keep prompting each other need your go from time to time.'
+        : 'Agents on different relays that keep prompting each other need your go from time to time.';
+    } else if (localSessions) {
+      rationale = 'Allow covers every session this conversation\'s agent starts on this relay; Deny refuses this one.';
+    }
+    // The same source for every card of this tool: it is what keeps agents
+    // (other relays' and this relay's own) from seeing or answering one.
     const context = sanitizeRelayQuestionContext({
       source: REMOTE_RELAY_APPROVAL_SOURCE,
-      rationale: `Write actions on other relays need approval in ${relayMode} mode.`,
+      rationale,
       queueMessageId: row.id,
       conversationId: toText(conversationId) || row.conversation_id,
       relayMode,
-      header: APPROVAL_HEADER,
+      header: localSessions ? LOCAL_SESSIONS_HEADER : APPROVAL_HEADER,
     }, { normalizeRelayMode: normalizeMode, defaultRelayMode });
     questionStatements.insertQuestion.run(
       questionId,

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

@@ -121,6 +121,15 @@ function networkError(relay, error, timeoutMs) {
   );
 }
 
+/**
+ * The error for a relay that answered with a non-2xx status and (maybe) a JSON
+ * body. Shared with the in-process loopback, so a refusal of this relay's own
+ * routes reads exactly like a paired relay's.
+ */
+export function remoteRelayHttpError(relay, status, body) {
+  return httpError(relay, status, body);
+}
+
 function httpError(relay, status, body) {
   const remoteError = isPlainObject(body) && toText(body.error) ? toText(body.error).slice(0, REMOTE_ERROR_TEXT_MAX) : null;
   const remoteCode = isPlainObject(body) && toText(body.code) ? toText(body.code).slice(0, 100) : null;