agent-office-cli 0.1.3 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-office-cli",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Run and manage AI agent sessions locally, with optional relay to agentoffice.top",
   "license": "MIT",
   "engines": {

package/src/core/providers/codex.js

@@ -1,31 +1,41 @@
+const { displayZoneFor } = require("../state");
 const { GenericProvider } = require("./generic");
 const { findManagedCodexSessionFile, summarizeCodexSession } = require("./codex-transcript");
 
-const APPROVAL_PATTERNS = [
-  "approval requested:",
-  "approval requested by ",
-  "tool call needs your approval",
-  "requires approval by policy",
-  "requires approval:"
+const APPROVAL_LINE_PATTERNS = [
+  /^approval requested:/i,
+  /^approval requested by /i,
+  /^tool call needs your approval$/i,
+  /^requires approval by policy$/i,
+  /^requires approval:/i
 ];
 
-const IDLE_PATTERNS = [
-  "conversation interrupted - tell the model what to do differently",
-  "something went wrong? hit `/feedback` to",
-  "something went wrong? hit /feedback to"
+const IDLE_LINE_PATTERNS = [
+  /^conversation interrupted - tell the model what to do differently/i,
+  /^something went wrong\? hit `?\/feedback`? to/i
 ];
 
-const ATTENTION_PATTERNS = [
-  "stream disconnected before completion",
-  "error sending request for url",
-  "network error",
-  "connection timeout",
-  "timed out",
-  "failed to send request",
-  "failed to submit",
-  "panic"
+const STATUS_LINE_CONTINUATION = String.raw`(?:$|[\s:.,;(])`;
+
+const ATTENTION_LINE_PATTERNS = [
+  new RegExp(`^stream disconnected before completion${STATUS_LINE_CONTINUATION}`, "i"),
+  new RegExp(`^error sending request for url${STATUS_LINE_CONTINUATION}`, "i"),
+  new RegExp(`^network error${STATUS_LINE_CONTINUATION}`, "i"),
+  new RegExp(`^connection timeout${STATUS_LINE_CONTINUATION}`, "i"),
+  new RegExp(`^timed out${STATUS_LINE_CONTINUATION}`, "i"),
+  new RegExp(`^failed to send request${STATUS_LINE_CONTINUATION}`, "i"),
+  new RegExp(`^failed to submit${STATUS_LINE_CONTINUATION}`, "i"),
+  new RegExp(`^panic${STATUS_LINE_CONTINUATION}`, "i")
 ];
 
+function matchesAnyLine(text, patterns) {
+  return String(text)
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .some((line) => patterns.some((pattern) => pattern.test(line)));
+}
+
 function activeOverlayPatch(session, nextLifecycleState) {
   if (!session || !["approval", "attention"].includes(session.displayState)) {
     return null;
@@ -72,23 +82,43 @@ class CodexProvider extends GenericProvider {
   }
 
   classifyOutput(chunk) {
-    const text = String(chunk).toLowerCase();
-
-    if (IDLE_PATTERNS.some((pattern) => text.includes(pattern))) {
+    if (matchesAnyLine(chunk, IDLE_LINE_PATTERNS)) {
       return "idle";
     }
 
-    if (APPROVAL_PATTERNS.some((pattern) => text.includes(pattern))) {
+    if (matchesAnyLine(chunk, APPROVAL_LINE_PATTERNS)) {
       return "approval";
     }
 
-    if (ATTENTION_PATTERNS.some((pattern) => text.includes(pattern))) {
+    if (matchesAnyLine(chunk, ATTENTION_LINE_PATTERNS)) {
       return "attention";
     }
 
     return null;
   }
 
+  getOverlayDisplayPatch(session, overlayState) {
+    if (!overlayState) {
+      if (session && session.displayState === "attention") {
+        const nextDisplayState = session.state || "working";
+        return {
+          displayState: nextDisplayState,
+          displayZone: displayZoneFor(nextDisplayState)
+        };
+      }
+      return null;
+    }
+
+    if (session && overlayState === session.displayState) {
+      return null;
+    }
+
+    return {
+      displayState: overlayState,
+      displayZone: displayZoneFor(overlayState)
+    };
+  }
+
   reconcileSession(session, context = {}) {
     if (session.status === "exited") {
       return null;

package/src/core/providers/codex.test.js

@@ -91,6 +91,19 @@ test("classifyOutput treats stream disconnects as attention", () => {
   assert.equal(nextState, "attention");
 });
 
+test("classifyOutput ignores diagnostic text that only mentions attention patterns", () => {
+  const provider = new CodexProvider();
+  const nextState = provider.classifyOutput(
+    [
+      'rg -n -i "conversation interrupted|error sending request for url|network error|timed out|failed to send request|failed to submit|panic|fetch failed"',
+      'const nextState = provider.classifyOutput("network error: connection timed out", { meta: { codexSessionPath: "/tmp/mock-codex.jsonl" } });',
+      'The changelog says stream disconnected before completion should surface as attention.'
+    ].join("\n")
+  );
+
+  assert.equal(nextState, null);
+});
+
 test("classifyOutput does not treat plain explanatory approval text as a real approval prompt", () => {
   const provider = new CodexProvider();
   const nextState = provider.classifyOutput(
@@ -108,3 +121,20 @@ test("classifyOutput recognizes real Codex approval prompts", () => {
 
   assert.equal(nextState, "approval");
 });
+
+test("getOverlayDisplayPatch clears stale attention overlays back to the lifecycle state", () => {
+  const provider = new CodexProvider();
+  const patch = provider.getOverlayDisplayPatch(
+    {
+      state: "working",
+      displayState: "attention",
+      displayZone: "attention-zone"
+    },
+    null
+  );
+
+  assert.deepEqual(patch, {
+    displayState: "working",
+    displayZone: "working-zone"
+  });
+});

package/src/runtime/pty-manager.js

@@ -353,12 +353,21 @@ function createPtyManager({ store }) {
         const screen = await capturePane(runtime.tmuxSession);
         const latestSession = store.getSession(session.sessionId) || session;
         const overlayState = runtime.provider.classifyOutput(screen, latestSession);
-
-        if (overlayState && overlayState !== latestSession.displayState) {
+        const overlayPatch = typeof runtime.provider.getOverlayDisplayPatch === "function"
+          ? runtime.provider.getOverlayDisplayPatch(latestSession, overlayState)
+          : (
+              overlayState && overlayState !== latestSession.displayState
+                ? {
+                    displayState: overlayState,
+                    displayZone: displayZoneFor(overlayState)
+                  }
+                : null
+            );
+
+        if (overlayPatch) {
           store.setSessionState(session.sessionId, latestSession.state || "working", {
             status: "running",
-            displayState: overlayState,
-            displayZone: displayZoneFor(overlayState)
+            ...overlayPatch
           });
         }
 

package/src/tunnel.js

@@ -3,6 +3,42 @@ const { toSessionSummary } = require("./core");
 
 const RECONNECT_BASE_MS = 1000;
 const RECONNECT_MAX_MS = 30000;
+const LOCAL_PROXY_STRIP_HEADERS = new Set([
+  "accept-encoding",
+  "connection",
+  "content-length",
+  "cookie",
+  "origin",
+  "referer",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
+
+function shouldStripLocalProxyHeader(name) {
+  return (
+    LOCAL_PROXY_STRIP_HEADERS.has(name) ||
+    name.startsWith("proxy-") ||
+    name.startsWith("sec-") ||
+    name.startsWith("x-forwarded-")
+  );
+}
+
+function buildLocalRequestHeaders(headers, localServerUrl) {
+  const nextHeaders = {};
+
+  for (const [name, rawValue] of Object.entries(headers || {})) {
+    const key = String(name).toLowerCase();
+    if (shouldStripLocalProxyHeader(key) || rawValue == null) {
+      continue;
+    }
+    nextHeaders[key] = Array.isArray(rawValue) ? rawValue.join(", ") : String(rawValue);
+  }
+
+  nextHeaders.host = new URL(localServerUrl).host;
+  return nextHeaders;
+}
 
 function createTunnelClient({ key, relayUrl, localServerUrl }) {
   let ws = null;
@@ -116,7 +152,7 @@ function createTunnelClient({ key, relayUrl, localServerUrl }) {
       const fetchUrl = `${localServerUrl}${msg.path}`;
       const fetchOptions = {
         method: msg.method || "GET",
-        headers: { ...msg.headers, host: new URL(localServerUrl).host }
+        headers: buildLocalRequestHeaders(msg.headers, localServerUrl)
       };
       if (msg.body && msg.method !== "GET" && msg.method !== "HEAD") {
         fetchOptions.body = msg.body;
@@ -220,5 +256,6 @@ function createTunnelClient({ key, relayUrl, localServerUrl }) {
 }
 
 module.exports = {
+  buildLocalRequestHeaders,
   createTunnelClient
 };

package/src/tunnel.test.js

@@ -0,0 +1,31 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const { buildLocalRequestHeaders } = require("./tunnel");
+
+test("buildLocalRequestHeaders strips browser-only proxy headers and rewrites host", () => {
+  const next = buildLocalRequestHeaders(
+    {
+      authorization: "Bearer token",
+      accept: "*/*",
+      "content-type": "application/json",
+      host: "agentoffice.top",
+      connection: "keep-alive",
+      "accept-encoding": "gzip, deflate, br, zstd",
+      "content-length": "123",
+      origin: "https://agentoffice.top",
+      referer: "https://agentoffice.top/office",
+      "sec-ch-ua": "\"Chromium\";v=\"146\"",
+      "sec-fetch-mode": "cors",
+      "x-forwarded-for": "203.0.113.10"
+    },
+    "http://127.0.0.1:8765"
+  );
+
+  assert.deepEqual(next, {
+    authorization: "Bearer token",
+    accept: "*/*",
+    "content-type": "application/json",
+    host: "127.0.0.1:8765"
+  });
+});