@oar-sh/oar 0.9.4 → 0.9.5

package/shared/steer-settle-markers.mjs

@@ -16,3 +16,19 @@ export const STEER_FOLDED_TEXT = '_(Handled together with the previous reply —
  * kind='stopped' — the stable handle the client keys its Resend on.
  */
 export const STEER_STOPPED_TEXT = '_(Stopped with the turn — not answered.)_';
+
+/**
+ * Not a steer: a message delivered between turns whose answer the worker
+ * published on a background-continuation row, because it took the turn for one
+ * the CLI had opened by itself. Stamped with a kind of its own: it is a
+ * marker, not a reply (no completion push, muted in the transcript, never
+ * handed to a calling relay as the answer), and not a steer marker either,
+ * which would label the message "steered mid-turn".
+ *
+ * The wording names the reply by its badge, not by its position: a live
+ * append puts the marker below that reply, a reload anchors it under its own
+ * message and so above it. The worker infers all this from silence, hence the
+ * way out at the end.
+ */
+export const ANSWERED_ELSEWHERE_KIND = 'answered-elsewhere';
+export const DELIVERY_ANSWERED_ELSEWHERE_TEXT = '_(Answered in the reply marked “background continuation” next to this message. Resend the message if that reply does not answer it.)_';

package/shared/worker-runtime/worker-log-file.mjs

@@ -0,0 +1,97 @@
+// The worker log for launches that cannot redirect the worker's output.
+//
+// On Linux the launcher redirects a Node worker's stdout/stderr into
+// `<log dir>/worker-<session id>.log` (`>> file 2>&1` under tmux, an inherited
+// descriptor on the detached path). On Windows the worker runs in its own
+// console window behind `cmd /c start`: no descriptor of the launcher reaches
+// it, and a shell redirect would empty the window. So the launcher names the
+// file in `COPILOT_WEB_RELAY_WORKER_LOG_FILE` and the worker copies what it
+// writes to stdout/stderr into it, while the console keeps showing the same
+// lines.
+//
+// Out of reach from inside the process: what Node prints natively (a V8 fatal
+// error such as heap exhaustion, a module that fails to load before this is
+// installed) and what a child process writes to an inherited console.
+import fs from 'fs';
+
+export const WORKER_LOG_FILE_ENV = 'COPILOT_WEB_RELAY_WORKER_LOG_FILE';
+
+// Colours are for the console; the Linux file never has them, because there
+// stdout is not a terminal.
+const ANSI_STYLE_PATTERN = /\u001b\[[0-9;]*m/g;
+
+/**
+ * Copies stdout/stderr into the log file the launcher named. Returns null when
+ * no file was named or it cannot be opened: best-effort like the launcher's
+ * side, a log problem must never stop a worker.
+ */
+export function installWorkerLogFile({
+  env = process.env,
+  processImpl = process,
+  fsImpl = fs,
+} = {}) {
+  const logPath = String(env?.[WORKER_LOG_FILE_ENV] || '').trim();
+  // Not inherited: the provider CLI, the agent's shells and anything started
+  // from them must not write into this worker's log.
+  if (env && WORKER_LOG_FILE_ENV in env) delete env[WORKER_LOG_FILE_ENV];
+  if (!logPath) return null;
+
+  let fd = null;
+  try {
+    fd = fsImpl.openSync(logPath, 'a');
+  } catch {
+    return null;
+  }
+
+  // Synchronous on purpose: the last lines before a process.exit() are the
+  // ones an incident needs.
+  const append = (chunk, encoding) => {
+    if (fd === null) return;
+    try {
+      if (typeof chunk === 'string') {
+        const text = chunk.replace(ANSI_STYLE_PATTERN, '');
+        if (text) fsImpl.writeSync(fd, text, null, typeof encoding === 'string' ? encoding : 'utf8');
+      } else if (chunk instanceof Uint8Array) {
+        fsImpl.writeSync(fd, chunk);
+      }
+    } catch {
+      // A file that stopped taking writes (disk full, handle gone) is given up.
+      try { fsImpl.closeSync(fd); } catch {}
+      fd = null;
+    }
+  };
+
+  const restores = [];
+  for (const stream of [processImpl.stdout, processImpl.stderr]) {
+    if (!stream || typeof stream.write !== 'function') continue;
+    const originalWrite = stream.write;
+    const teeWrite = function teeWrite(chunk, encoding, callback) {
+      append(chunk, encoding);
+      return originalWrite.call(this, chunk, encoding, callback);
+    };
+    stream.write = teeWrite;
+    restores.push(() => {
+      if (stream.write === teeWrite) stream.write = originalWrite;
+    });
+  }
+
+  // Without an uncaughtException handler Node prints the error natively, past
+  // the streams above. With one (the worker crash guard) the handler logs it.
+  const onUncaught = (error, origin) => {
+    if (processImpl.listenerCount('uncaughtException') > 0) return;
+    append(`${origin || 'uncaughtException'}: ${error?.stack || error?.message || error}\n`);
+  };
+  processImpl.on?.('uncaughtExceptionMonitor', onUncaught);
+
+  return {
+    logPath,
+    uninstall() {
+      for (const restore of restores) restore();
+      processImpl.off?.('uncaughtExceptionMonitor', onUncaught);
+      if (fd !== null) {
+        try { fsImpl.closeSync(fd); } catch {}
+        fd = null;
+      }
+    },
+  };
+}