agent-office-cli 0.1.4 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-office-cli",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "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/index.js

@@ -19,6 +19,7 @@ const {
   createPtyManager,
   defaultTransportForProvider,
   ensureNodePtySpawnHelper,
+  startSleepInhibitor,
   listSessionRecords,
   removeSessionRecord,
   applyClaudeHookConfig,
@@ -172,6 +173,13 @@ async function main() {
       throw new Error("tmux is required for AgentOffice local sessions. Install it first, for example with `brew install tmux`.");
     }
 
+    const sleepInhibitor = startSleepInhibitor({ commandExists });
+    if (sleepInhibitor.started) {
+      console.log("- sleep guard: caffeinate active");
+    } else if (process.platform === "darwin") {
+      console.log("- sleep guard: skipped (caffeinate unavailable)");
+    }
+
     const store = createSessionStore();
     const ptyManager = createPtyManager({ store });
     const restored = ptyManager.restoreManagedSessions();

package/src/runtime/index.js

@@ -18,6 +18,7 @@ const {
   removeSessionRecord
 } = require("./session-registry");
 const { ensureNodePtySpawnHelper } = require("./ensure-node-pty");
+const { startSleepInhibitor } = require("./sleep-inhibitor");
 const {
   applyClaudeHookConfig,
   claudeSettingsPath,
@@ -45,6 +46,7 @@ module.exports = {
   persistSessionRecord,
   removeSessionRecord,
   ensureNodePtySpawnHelper,
+  startSleepInhibitor,
   applyClaudeHookConfig,
   claudeSettingsPath,
   commandExists,

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/runtime/sleep-inhibitor.js

@@ -0,0 +1,31 @@
+const { spawn } = require("node:child_process");
+
+function startSleepInhibitor({
+  pid = process.pid,
+  platform = process.platform,
+  commandExists = () => true,
+  spawn: spawnProcess = spawn
+} = {}) {
+  if (platform !== "darwin") {
+    return { started: false, reason: "unsupported_platform" };
+  }
+
+  if (!commandExists("caffeinate")) {
+    return { started: false, reason: "missing_command" };
+  }
+
+  const child = spawnProcess("caffeinate", ["-dimsu", "-w", String(pid)], {
+    stdio: "ignore"
+  });
+  child.unref?.();
+
+  return {
+    started: true,
+    reason: "started",
+    child
+  };
+}
+
+module.exports = {
+  startSleepInhibitor
+};

package/src/runtime/sleep-inhibitor.test.js

@@ -0,0 +1,63 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const { startSleepInhibitor } = require("./sleep-inhibitor");
+
+test("startSleepInhibitor starts caffeinate by default on macOS", () => {
+  const calls = [];
+  const child = {
+    unrefCalled: false,
+    unref() {
+      this.unrefCalled = true;
+    }
+  };
+
+  const result = startSleepInhibitor({
+    pid: 4321,
+    platform: "darwin",
+    commandExists: (command) => command === "caffeinate",
+    spawn: (command, args, options) => {
+      calls.push({ command, args, options });
+      return child;
+    }
+  });
+
+  assert.deepEqual(calls, [
+    {
+      command: "caffeinate",
+      args: ["-dimsu", "-w", "4321"],
+      options: { stdio: "ignore" }
+    }
+  ]);
+  assert.equal(child.unrefCalled, true);
+  assert.equal(result.started, true);
+  assert.equal(result.reason, "started");
+});
+
+test("startSleepInhibitor skips non-macOS platforms", () => {
+  const result = startSleepInhibitor({
+    pid: 4321,
+    platform: "linux",
+    commandExists: () => true,
+    spawn: () => {
+      throw new Error("spawn should not be called");
+    }
+  });
+
+  assert.equal(result.started, false);
+  assert.equal(result.reason, "unsupported_platform");
+});
+
+test("startSleepInhibitor skips when caffeinate is unavailable", () => {
+  const result = startSleepInhibitor({
+    pid: 4321,
+    platform: "darwin",
+    commandExists: () => false,
+    spawn: () => {
+      throw new Error("spawn should not be called");
+    }
+  });
+
+  assert.equal(result.started, false);
+  assert.equal(result.reason, "missing_command");
+});