agent-office-cli 0.1.0 → 0.1.2

package/package.json

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

package/src/core/config.js

@@ -3,11 +3,13 @@ const DEFAULT_LAN_HOST = "0.0.0.0";
 const DEFAULT_PORT = 8765;
 const DEFAULT_SERVER_URL = `http://${DEFAULT_HOST}:${DEFAULT_PORT}`;
 const LOG_LIMIT = 1000;
+const TERMINAL_REPLAY_LIMIT = 128 * 1024;
 
 module.exports = {
   DEFAULT_HOST,
   DEFAULT_LAN_HOST,
   DEFAULT_PORT,
   DEFAULT_SERVER_URL,
-  LOG_LIMIT
+  LOG_LIMIT,
+  TERMINAL_REPLAY_LIMIT
 };

package/src/core/providers/codex.js

@@ -1,6 +1,32 @@
 const { GenericProvider } = require("./generic");
 const { findManagedCodexSessionFile, summarizeCodexSession } = require("./codex-transcript");
 
+function activeOverlayPatch(session, nextLifecycleState) {
+  if (!session || !["approval", "attention"].includes(session.displayState)) {
+    return null;
+  }
+
+  if (nextLifecycleState === "idle") {
+    return {
+      displayState: "idle",
+      displayZone: "idle-zone",
+      meta: {
+        overlayState: null,
+        overlayUpdatedAt: null
+      }
+    };
+  }
+
+  return {
+    displayState: session.displayState,
+    displayZone: session.displayZone,
+    meta: {
+      overlayState: session.displayState,
+      overlayUpdatedAt: session.updatedAt || null
+    }
+  };
+}
+
 class CodexProvider extends GenericProvider {
   constructor() {
     super("codex");
@@ -25,7 +51,14 @@ class CodexProvider extends GenericProvider {
     if (text.includes("approval") || text.includes("press enter") || text.includes("confirm")) {
       return "approval";
     }
-    if (text.includes("error") || text.includes("failed") || text.includes("panic")) {
+    if (
+      text.includes("network error") ||
+      text.includes("connection timeout") ||
+      text.includes("timed out") ||
+      text.includes("error") ||
+      text.includes("failed") ||
+      text.includes("panic")
+    ) {
       return "attention";
     }
     return null;
@@ -50,7 +83,8 @@ class CodexProvider extends GenericProvider {
     };
 
     const previousPath = session.meta && session.meta.codexSessionPath;
-    const previousState = session.displayState;
+    const overlay = activeOverlayPatch(session, summary.state);
+    const previousState = session.state;
     const previousCursor = session.meta && session.meta.codexTranscriptCursor;
     const previousLifecycle = session.meta && session.meta.codexLastLifecycle;
     const lifecycleAdvanced = Boolean(summary.lastTimestamp && summary.lastTimestamp !== previousCursor);
@@ -68,20 +102,32 @@ class CodexProvider extends GenericProvider {
     return {
       session: metaChanged
         ? {
-        meta: nextMeta
+            meta: nextMeta
           }
         : null,
       state: summary.state,
-      patch: summary.state ? { status: "running" } : null,
-      eventName: lifecycleAdvanced && summary.lastLifecycle ? `codex_${summary.lastLifecycle}` : null,
-      meta: lifecycleAdvanced
+      patch: summary.state
         ? {
-            codexSessionPath: matched.path,
-            codexSessionId: matched.sessionMeta && matched.sessionMeta.id,
-            turnId: summary.lastTurnId || null,
-            lastAgentMessage: summary.lastAgentMessage || null
+            status: "running",
+            ...(overlay
+              ? {
+                  displayState: overlay.displayState,
+                  displayZone: overlay.displayZone
+                }
+              : {})
           }
-        : null
+        : null,
+      eventName: lifecycleAdvanced && summary.lastLifecycle ? `codex_${summary.lastLifecycle}` : null,
+      meta:
+        lifecycleAdvanced || overlay
+          ? {
+              codexSessionPath: matched.path,
+              codexSessionId: matched.sessionMeta && matched.sessionMeta.id,
+              turnId: summary.lastTurnId || null,
+              lastAgentMessage: summary.lastAgentMessage || null,
+              ...(overlay ? overlay.meta : {})
+            }
+          : null
     };
   }
 }

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

@@ -0,0 +1,74 @@
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const { CodexProvider } = require("./codex");
+
+function writeTranscriptFile(entries) {
+  const dirPath = fs.mkdtempSync(path.join(os.tmpdir(), "codex-transcript-"));
+  const filePath = path.join(dirPath, "session.jsonl");
+  fs.writeFileSync(
+    filePath,
+    `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`,
+    "utf8"
+  );
+  return filePath;
+}
+
+test("reconcileSession keeps approval display overlay when transcript advances to working", () => {
+  const transcriptPath = writeTranscriptFile([
+    {
+      type: "session_meta",
+      payload: {
+        id: "codex-session-1",
+        cwd: process.cwd(),
+        timestamp: "2026-03-18T10:00:00.000Z"
+      }
+    },
+    {
+      timestamp: "2026-03-18T10:00:01.000Z",
+      type: "event_msg",
+      payload: {
+        type: "task_started",
+        turn_id: "turn-1"
+      }
+    }
+  ]);
+
+  const provider = new CodexProvider();
+  const session = provider.createSession({
+    cwd: process.cwd(),
+    title: "Codex",
+    command: "codex",
+    meta: {
+      codexSessionPath: transcriptPath,
+      codexTranscriptCursor: null,
+      codexLastLifecycle: null
+    }
+  });
+  session.status = "running";
+  session.state = "working";
+  session.displayState = "approval";
+  session.displayZone = "approval-zone";
+  session.updatedAt = "2026-03-18T10:00:02.000Z";
+
+  const result = provider.reconcileSession(session, { sessions: [session] });
+
+  assert.ok(result);
+  assert.equal(result.state, "working");
+  assert.equal(result.patch.displayState, "approval");
+  assert.equal(result.patch.displayZone, "approval-zone");
+});
+
+test("classifyOutput can raise attention for transcript-backed sessions", () => {
+  const provider = new CodexProvider();
+  const nextState = provider.classifyOutput("network error: connection timed out", {
+    meta: {
+      codexSessionPath: "/tmp/mock-codex.jsonl"
+    }
+  });
+
+  assert.equal(nextState, "attention");
+});

package/src/core/session-contract.js

@@ -1,9 +1,11 @@
+const { displayZoneFor } = require("./state");
+
 const CONTRACT_VERSION = 1;
 
 function sessionLifecycle(session) {
   const status = session.status || "registered";
   const displayState = session.displayState || session.state || "idle";
-  const displayZone = session.displayZone || "working-zone";
+  const displayZone = session.displayZone || displayZoneFor(displayState);
 
   return {
     status,

package/src/core/session-contract.test.js

@@ -0,0 +1,27 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const { toPublicSession } = require("./session-contract");
+
+test("toPublicSession derives displayZone from displayState when zone is missing", () => {
+  const session = toPublicSession({
+    sessionId: "sess_3",
+    provider: "codex",
+    title: "Codex",
+    command: "codex",
+    cwd: process.cwd(),
+    mode: "managed",
+    transport: "tmux",
+    state: "working",
+    displayState: "approval",
+    status: "running",
+    createdAt: "2026-03-18T00:00:00.000Z",
+    updatedAt: "2026-03-18T00:00:01.000Z",
+    meta: {}
+  });
+
+  assert.equal(session.state, "working");
+  assert.equal(session.displayState, "approval");
+  assert.equal(session.displayZone, "approval-zone");
+  assert.equal(session.lifecycle.displayZone, "approval-zone");
+});

package/src/core/store/session-store.js

@@ -1,7 +1,7 @@
 const { EventEmitter } = require("node:events");
 const os = require("node:os");
 const crypto = require("node:crypto");
-const { LOG_LIMIT } = require("../config");
+const { LOG_LIMIT, TERMINAL_REPLAY_LIMIT } = require("../config");
 const { displayZoneFor } = require("../state");
 const { toPublicSession, toSessionSummary } = require("../session-contract");
 
@@ -13,10 +13,14 @@ function cloneSession(session) {
   return toPublicSession(session);
 }
 
+function applyDisplay(session, nextDisplayState, nextDisplayZone = null) {
+  session.displayState = nextDisplayState;
+  session.displayZone = nextDisplayZone || displayZoneFor(nextDisplayState);
+}
+
 function applyState(session, nextState) {
   session.state = nextState;
-  session.displayState = nextState;
-  session.displayZone = displayZoneFor(nextState);
+  applyDisplay(session, nextState);
 }
 
 function createSessionStore() {
@@ -26,6 +30,7 @@ function createSessionStore() {
   function buildSession(payload) {
     const sessionId = payload.sessionId || `sess_${crypto.randomBytes(5).toString("hex")}`;
     const state = payload.state || "idle";
+    const displayState = payload.displayState || state;
     const createdAt = payload.createdAt || isoNow();
     const updatedAt = payload.updatedAt || createdAt;
 
@@ -38,8 +43,8 @@ function createSessionStore() {
       mode: payload.mode || "managed",
       transport: payload.transport || "pty",
       state,
-      displayState: payload.displayState || state,
-      displayZone: payload.displayZone || displayZoneFor(state),
+      displayState,
+      displayZone: payload.displayZone || displayZoneFor(displayState),
       status: payload.status || "registered",
       createdAt,
       updatedAt,
@@ -48,7 +53,8 @@ function createSessionStore() {
       host: payload.host || os.hostname(),
       meta: { ...(payload.meta || {}) },
       logs: [...(payload.logs || [])],
-      events: [...(payload.events || [])]
+      events: [...(payload.events || [])],
+      terminalReplay: String(payload.terminalReplay || "")
     };
   }
 
@@ -86,10 +92,10 @@ function createSessionStore() {
     if (payload.state) {
       applyState(existing, payload.state);
     }
-    if (payload.displayState && !payload.state) {
-      existing.displayState = payload.displayState;
+    if (payload.displayState) {
+      applyDisplay(existing, payload.displayState, payload.displayZone);
     }
-    if (payload.displayZone && !payload.state) {
+    if (payload.displayZone && !payload.displayState) {
       existing.displayZone = payload.displayZone;
     }
     if (payload.status) {
@@ -110,9 +116,9 @@ function createSessionStore() {
     session.updatedAt = isoNow();
     Object.assign(session, patch);
     if (patch.displayState) {
-      session.displayState = patch.displayState;
+      applyDisplay(session, patch.displayState, patch.displayZone);
     }
-    if (patch.displayZone) {
+    if (patch.displayZone && !patch.displayState) {
       session.displayZone = patch.displayZone;
     }
     emitUpdate(sessionId);
@@ -146,6 +152,10 @@ function createSessionStore() {
     const lines = String(chunk).replace(/\r/g, "").split("\n").filter(Boolean);
     session.logs.push(...lines);
     session.logs = session.logs.slice(-LOG_LIMIT);
+    session.terminalReplay = `${session.terminalReplay || ""}${String(chunk)}`;
+    if (session.terminalReplay.length > TERMINAL_REPLAY_LIMIT) {
+      session.terminalReplay = session.terminalReplay.slice(-TERMINAL_REPLAY_LIMIT);
+    }
     session.lastOutputAt = isoNow();
     session.updatedAt = session.lastOutputAt;
     // Terminal output does not change session state — skip session:update broadcast.
@@ -164,13 +174,11 @@ function createSessionStore() {
     Object.assign(session, patch);
     if (patch.state) {
       applyState(session, patch.state);
-    } else {
-      if (patch.displayState) {
-        session.displayState = patch.displayState;
-      }
-      if (patch.displayZone) {
-        session.displayZone = patch.displayZone;
-      }
+    }
+    if (patch.displayState) {
+      applyDisplay(session, patch.displayState, patch.displayZone);
+    } else if (patch.displayZone) {
+      session.displayZone = patch.displayZone;
     }
     emitUpdate(sessionId);
     return session;
@@ -186,6 +194,11 @@ function createSessionStore() {
     return session ? toSessionSummary(session) : null;
   }
 
+  function getTerminalReplay(sessionId) {
+    const session = sessions.get(sessionId);
+    return session ? session.terminalReplay || "" : "";
+  }
+
   function listSessions() {
     return [...sessions.values()]
       .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
@@ -221,6 +234,7 @@ function createSessionStore() {
     markExit,
     getSession,
     getSessionSummary,
+    getTerminalReplay,
     listSessions,
     listSessionSummaries,
     removeSession

package/src/core/store/session-store.test.js

@@ -0,0 +1,68 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const { createSessionStore } = require("./session-store");
+
+test("setSessionState keeps lifecycle state and applies display override", () => {
+  const store = createSessionStore();
+  store.upsertSession({
+    sessionId: "sess_1",
+    provider: "codex",
+    title: "Codex",
+    command: "codex",
+    cwd: process.cwd(),
+    state: "idle",
+    status: "running"
+  });
+
+  const next = store.setSessionState("sess_1", "working", {
+    status: "running",
+    displayState: "approval",
+    displayZone: "approval-zone"
+  });
+
+  assert.equal(next.state, "working");
+  assert.equal(next.displayState, "approval");
+  assert.equal(next.displayZone, "approval-zone");
+  assert.equal(next.status, "running");
+});
+
+test("setSessionState derives displayZone from displayState override when zone is omitted", () => {
+  const store = createSessionStore();
+  store.upsertSession({
+    sessionId: "sess_2",
+    provider: "codex",
+    title: "Codex",
+    command: "codex",
+    cwd: process.cwd(),
+    state: "idle",
+    status: "running"
+  });
+
+  const next = store.setSessionState("sess_2", "working", {
+    status: "running",
+    displayState: "attention"
+  });
+
+  assert.equal(next.state, "working");
+  assert.equal(next.displayState, "attention");
+  assert.equal(next.displayZone, "attention-zone");
+});
+
+test("appendOutput keeps a raw terminal replay buffer for fast reconnects", () => {
+  const store = createSessionStore();
+  store.upsertSession({
+    sessionId: "sess_3",
+    provider: "generic",
+    title: "Shell",
+    command: "bash",
+    cwd: process.cwd(),
+    state: "working",
+    status: "running"
+  });
+
+  store.appendOutput("sess_3", "line one\r\n");
+  store.appendOutput("sess_3", "line two\n");
+
+  assert.equal(store.getTerminalReplay("sess_3"), "line one\r\nline two\n");
+});

package/src/runtime/postinstall-path.test.js

@@ -0,0 +1,26 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+test("root postinstall points at the live ensure-node-pty module", () => {
+  const rootDir = path.resolve(__dirname, "../../../../");
+  const packageJson = JSON.parse(fs.readFileSync(path.join(rootDir, "package.json"), "utf8"));
+  const postinstall = packageJson.scripts && packageJson.scripts.postinstall;
+
+  assert.match(postinstall, /packages\/cli\/src\/runtime\/ensure-node-pty/);
+});
+
+test("service packages no longer depend on @agent-office/core", () => {
+  const rootDir = path.resolve(__dirname, "../../../../");
+  const apiPackageJson = JSON.parse(fs.readFileSync(path.join(rootDir, "services/api/package.json"), "utf8"));
+  const relayPackageJson = JSON.parse(fs.readFileSync(path.join(rootDir, "services/relay/package.json"), "utf8"));
+
+  assert.ok(!("@agent-office/core" in (apiPackageJson.dependencies || {})));
+  assert.ok(!("@agent-office/core" in (relayPackageJson.dependencies || {})));
+});
+
+test("legacy packages/core package has been removed", () => {
+  const rootDir = path.resolve(__dirname, "../../../../");
+  assert.equal(fs.existsSync(path.join(rootDir, "packages/core")), false);
+});

package/src/runtime/pty-manager.js

@@ -1,7 +1,7 @@
 const crypto = require("node:crypto");
 const os = require("node:os");
 const pty = require("node-pty");
-const { getProvider } = require("../core");
+const { displayZoneFor, getProvider } = require("../core");
 const {
   AGENTOFFICE_TMUX_PREFIX,
   attachClient,
@@ -350,20 +350,21 @@ function createPtyManager({ store }) {
         }
 
         const provider = getProvider(session.provider);
-        const reconcileResult = provider.reconcileSession(session, { sessions: currentSessions });
-        // Only run screen-based classifyOutput when the session has no transcript-driven state.
-        // For providers like Codex that use a transcript (codexSessionPath set), classifyOutput
-        // on the raw terminal text is unreliable and fights the transcript state machine, causing
-        // the session to flicker between "attention" and "idle" every polling tick.
-        const hasTranscriptState = Boolean(session.meta && session.meta.codexSessionPath);
-        if (!hasTranscriptState && (!reconcileResult || !reconcileResult.state)) {
-          const screen = await capturePane(runtime.tmuxSession);
-          const nextState = runtime.provider.classifyOutput(screen, store.getSession(session.sessionId));
-          if (nextState && nextState !== session.displayState) {
-            store.setSessionState(session.sessionId, nextState, { status: "running" });
-          }
+        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) {
+          store.setSessionState(session.sessionId, latestSession.state || "working", {
+            status: "running",
+            displayState: overlayState,
+            displayZone: displayZoneFor(overlayState)
+          });
         }
-        applyProviderReconcile(session, reconcileResult);
+
+        const reconciledSession = store.getSession(session.sessionId) || session;
+        const reconcileResult = provider.reconcileSession(reconciledSession, { sessions: currentSessions });
+        applyProviderReconcile(reconciledSession, reconcileResult);
         continue;
       }
 
@@ -502,18 +503,25 @@ function createPtyManager({ store }) {
 
     let attachedClient = null;
     let tmuxStreamStarted = false;
+    let pendingCols = 120;
+    let pendingRows = 32;
 
     async function startTmuxStream(cols, rows) {
       if (tmuxStreamStarted || !entry || entry.transport !== "tmux") {
         return;
       }
       tmuxStreamStarted = true;
+      pendingCols = cols;
+      pendingRows = rows;
       try {
         const snapshot = await capturePane(entry.tmuxSession);
         if (snapshot && ws.readyState === 1) {
           ws.send(JSON.stringify({ type: "terminal:data", data: `${snapshot}\r\n` }));
         }
         attachedClient = attachClient(entry.tmuxSession, { cwd: entry.cwd, cols, rows });
+        if (pendingCols !== cols || pendingRows !== rows) {
+          attachedClient.resize(pendingCols, pendingRows);
+        }
         attachedClient.onData((chunk) => {
           if (ws.readyState === 1) {
             ws.send(JSON.stringify({ type: "terminal:data", data: chunk }));
@@ -531,7 +539,12 @@ function createPtyManager({ store }) {
 
     // For non-tmux transports that had immediate setup, keep original behavior
     if (entry && entry.transport === "pty") {
-      // PTY sessions stream via broadcastTerminal, no per-client attach needed
+      const replay = store.getTerminalReplay(sessionId);
+      if (replay) {
+        ws.send(JSON.stringify({ type: "terminal:data", data: replay }));
+      }
+    } else if (entry && entry.transport === "tmux") {
+      void startTmuxStream(120, 32);
     }
 
     ws.on("message", async (raw) => {
@@ -552,6 +565,8 @@ function createPtyManager({ store }) {
         if (message.type === "resize") {
           const cols = Number(message.cols || 120);
           const rows = Number(message.rows || 32);
+          pendingCols = cols;
+          pendingRows = rows;
           if (runtime.transport === "pty") {
             runtime.pty.resize(cols, rows);
           } else if (!tmuxStreamStarted) {

package/src/server.js

@@ -1,4 +1,7 @@
+const fs = require("node:fs");
 const http = require("node:http");
+const os = require("node:os");
+const path = require("node:path");
 const express = require("express");
 const { WebSocketServer } = require("ws");
 const auth = require("./auth");
@@ -112,6 +115,20 @@ function createAppServer({ host, port, store, ptyManager }) {
     res.json({ ok: true });
   });
 
+  // Returns home dir + subdirectories of a given path (for working directory picker)
+  app.get("/api/dirs", (req, res) => {
+    const home = os.homedir();
+    const target = String(req.query.path || home);
+    let entries = [];
+    try {
+      entries = fs.readdirSync(target, { withFileTypes: true })
+        .filter((e) => e.isDirectory() && !e.name.startsWith("."))
+        .map((e) => path.join(target, e.name))
+        .slice(0, 50);
+    } catch { /* unreadable dir */ }
+    res.json({ home, path: target, dirs: entries });
+  });
+
   app.get("/api/sessions", (_req, res) => {
     res.json({ sessions: store.listSessionSummaries() });
   });