agent-office-cli 0.0.1

package/src/core/providers/codex-transcript.js

@@ -0,0 +1,210 @@
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const CODEX_SESSIONS_ROOT = path.join(os.homedir(), ".codex", "sessions");
+
+function readJsonLinesHead(filePath, maxLines = 8) {
+  try {
+    const fd = fs.openSync(filePath, "r");
+    const buffer = Buffer.alloc(1048576);
+    const length = fs.readSync(fd, buffer, 0, buffer.length, 0);
+    fs.closeSync(fd);
+    const text = buffer.toString("utf8", 0, length);
+    return text
+      .split("\n")
+      .filter(Boolean)
+      .slice(0, maxLines)
+      .map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function readTranscriptTail(filePath, bytes = 1048576) {
+  try {
+    const stats = fs.statSync(filePath);
+    const start = Math.max(0, stats.size - bytes);
+    const length = stats.size - start;
+    const fd = fs.openSync(filePath, "r");
+    const buffer = Buffer.alloc(length);
+    fs.readSync(fd, buffer, 0, length, start);
+    fs.closeSync(fd);
+    return buffer.toString("utf8");
+  } catch {
+    return "";
+  }
+}
+
+function extractRecentEntries(filePath, count = 1000) {
+  const text = readTranscriptTail(filePath);
+  if (!text) {
+    return [];
+  }
+
+  return text
+    .split("\n")
+    .filter(Boolean)
+    .slice(-count)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+function listSessionFiles(root = CODEX_SESSIONS_ROOT) {
+  const files = [];
+
+  function walk(dirPath) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      const nextPath = path.join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        walk(nextPath);
+        continue;
+      }
+      if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
+        continue;
+      }
+      try {
+        const stats = fs.statSync(nextPath);
+        files.push({ path: nextPath, mtimeMs: stats.mtimeMs });
+      } catch {
+        // Ignore disappearing files from concurrent Codex writes.
+      }
+    }
+  }
+
+  walk(root);
+  files.sort((left, right) => right.mtimeMs - left.mtimeMs);
+  return files;
+}
+
+function readSessionMeta(filePath) {
+  const entries = readJsonLinesHead(filePath);
+  const sessionMeta = entries.find((entry) => entry.type === "session_meta");
+  return sessionMeta ? sessionMeta.payload || null : null;
+}
+
+function summarizeCodexSession(filePath) {
+  const entries = extractRecentEntries(filePath);
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    const payload = entry.payload || {};
+
+    if (entry.type === "event_msg") {
+      if (payload.type === "task_started") {
+        return {
+          state: "working",
+          lastLifecycle: "task_started",
+          lastTimestamp: entry.timestamp || null,
+          lastTurnId: payload.turn_id || null,
+          lastAgentMessage: null
+        };
+      }
+
+      if (payload.type === "task_complete") {
+        return {
+          state: "idle",
+          lastLifecycle: "task_complete",
+          lastTimestamp: entry.timestamp || null,
+          lastTurnId: payload.turn_id || null,
+          lastAgentMessage: payload.last_agent_message || null
+        };
+      }
+
+      if (payload.type === "turn_aborted") {
+        return {
+          state: "idle",
+          lastLifecycle: "turn_aborted",
+          lastTimestamp: entry.timestamp || null,
+          lastTurnId: payload.turn_id || null,
+          lastAgentMessage: null
+        };
+      }
+    }
+  }
+
+  return {
+    state: null,
+    lastLifecycle: null,
+    lastTimestamp: null,
+    lastTurnId: null,
+    lastAgentMessage: null
+  };
+}
+
+function findManagedCodexSessionFile(session, allSessions = []) {
+  const linkedPath = session.meta && session.meta.codexSessionPath;
+  if (linkedPath && fs.existsSync(linkedPath)) {
+    return {
+      path: linkedPath,
+      sessionMeta: readSessionMeta(linkedPath)
+    };
+  }
+
+  const assignedPaths = new Set(
+    allSessions
+      .filter((entry) => entry.sessionId !== session.sessionId)
+      .map((entry) => entry.meta && entry.meta.codexSessionPath)
+      .filter(Boolean)
+  );
+
+  const sessionStartMs = Date.parse((session.meta && session.meta.managedStartedAt) || session.createdAt || session.updatedAt || 0);
+  const candidates = listSessionFiles()
+    .filter((entry) => !assignedPaths.has(entry.path))
+    .slice(0, 80)
+    .map((entry) => ({
+      ...entry,
+      sessionMeta: readSessionMeta(entry.path)
+    }))
+    .filter((entry) => entry.sessionMeta && entry.sessionMeta.cwd === session.cwd)
+    .map((entry) => {
+      const metaTimestampMs = Date.parse(entry.sessionMeta.timestamp || 0);
+      const effectiveTimeMs = Number.isFinite(metaTimestampMs) && metaTimestampMs > 0 ? metaTimestampMs : entry.mtimeMs;
+      const deltaMs = Math.abs(effectiveTimeMs - sessionStartMs);
+      const score =
+        (entry.mtimeMs >= sessionStartMs - 15000 ? 60 : 0) +
+        Math.max(0, 40 - Math.floor(deltaMs / 30000));
+      return {
+        ...entry,
+        score,
+        deltaMs,
+        effectiveTimeMs
+      };
+    })
+    .filter((entry) => entry.score > 0)
+    .sort((left, right) => right.score - left.score || right.effectiveTimeMs - left.effectiveTimeMs);
+
+  if (candidates.length === 0) {
+    return null;
+  }
+
+  return {
+    path: candidates[0].path,
+    sessionMeta: candidates[0].sessionMeta
+  };
+}
+
+module.exports = {
+  CODEX_SESSIONS_ROOT,
+  findManagedCodexSessionFile,
+  summarizeCodexSession
+};

package/src/core/providers/codex.js

@@ -0,0 +1,91 @@
+const { GenericProvider } = require("./generic");
+const { findManagedCodexSessionFile, summarizeCodexSession } = require("./codex-transcript");
+
+class CodexProvider extends GenericProvider {
+  constructor() {
+    super("codex");
+  }
+
+  createSession(payload) {
+    return {
+      ...super.createSession(payload),
+      meta: {
+        managedStartedAt: new Date().toISOString(),
+        codexSessionPath: null,
+        codexSessionId: null,
+        codexTranscriptCursor: null,
+        codexLastLifecycle: null,
+        ...(payload.meta || {})
+      }
+    };
+  }
+
+  classifyOutput(chunk) {
+    const text = String(chunk).toLowerCase();
+    if (text.includes("approval") || text.includes("press enter") || text.includes("confirm")) {
+      return "approval";
+    }
+    if (text.includes("error") || text.includes("failed") || text.includes("panic")) {
+      return "attention";
+    }
+    return null;
+  }
+
+  reconcileSession(session, context = {}) {
+    if (session.status === "exited") {
+      return null;
+    }
+
+    const matched = findManagedCodexSessionFile(session, context.sessions || []);
+    if (!matched || !matched.path) {
+      return null;
+    }
+
+    const summary = summarizeCodexSession(matched.path);
+    const nextMeta = {
+      codexSessionPath: matched.path,
+      codexSessionId: matched.sessionMeta && matched.sessionMeta.id,
+      codexTranscriptCursor: summary.lastTimestamp || null,
+      codexLastLifecycle: summary.lastLifecycle || null
+    };
+
+    const previousPath = session.meta && session.meta.codexSessionPath;
+    const previousState = session.displayState;
+    const previousCursor = session.meta && session.meta.codexTranscriptCursor;
+    const previousLifecycle = session.meta && session.meta.codexLastLifecycle;
+    const lifecycleAdvanced = Boolean(summary.lastTimestamp && summary.lastTimestamp !== previousCursor);
+    const metaChanged =
+      previousPath !== nextMeta.codexSessionPath ||
+      (session.meta && session.meta.codexSessionId) !== nextMeta.codexSessionId ||
+      previousCursor !== nextMeta.codexTranscriptCursor ||
+      previousLifecycle !== nextMeta.codexLastLifecycle;
+    const stateChanged = Boolean(summary.state && summary.state !== previousState);
+
+    if (!metaChanged && !stateChanged && !lifecycleAdvanced) {
+      return null;
+    }
+
+    return {
+      session: metaChanged
+        ? {
+        meta: nextMeta
+          }
+        : null,
+      state: summary.state,
+      patch: summary.state ? { status: "running" } : null,
+      eventName: lifecycleAdvanced && summary.lastLifecycle ? `codex_${summary.lastLifecycle}` : null,
+      meta: lifecycleAdvanced
+        ? {
+            codexSessionPath: matched.path,
+            codexSessionId: matched.sessionMeta && matched.sessionMeta.id,
+            turnId: summary.lastTurnId || null,
+            lastAgentMessage: summary.lastAgentMessage || null
+          }
+        : null
+    };
+  }
+}
+
+module.exports = {
+  CodexProvider
+};

package/src/core/providers/generic.js

@@ -0,0 +1,40 @@
+const { BaseProvider } = require("./base");
+
+const ATTENTION_PATTERNS = [
+  "traceback",
+  "fatal",
+  "command not found",
+  "permission denied",
+  "access denied",
+  "exception"
+];
+
+const WAITING_PATTERNS = [
+  "approve",
+  "approval",
+  "waiting for input",
+  "confirm",
+  "press enter",
+  "continue?"
+];
+
+class GenericProvider extends BaseProvider {
+  constructor(name = "generic") {
+    super(name);
+  }
+
+  classifyOutput(chunk) {
+    const text = String(chunk).toLowerCase();
+    if (WAITING_PATTERNS.some((pattern) => text.includes(pattern))) {
+      return "approval";
+    }
+    if (ATTENTION_PATTERNS.some((pattern) => text.includes(pattern))) {
+      return "attention";
+    }
+    return "working";
+  }
+}
+
+module.exports = {
+  GenericProvider
+};

package/src/core/providers/index.js

@@ -0,0 +1,17 @@
+const { ClaudeProvider } = require("./claude");
+const { CodexProvider } = require("./codex");
+const { GenericProvider } = require("./generic");
+
+const providers = {
+  claude: new ClaudeProvider(),
+  codex: new CodexProvider(),
+  generic: new GenericProvider("generic")
+};
+
+function getProvider(name) {
+  return providers[name] || new GenericProvider(name || "generic");
+}
+
+module.exports = {
+  getProvider
+};

package/src/core/session-contract.js

@@ -0,0 +1,98 @@
+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";
+
+  return {
+    status,
+    state: session.state || displayState,
+    displayState,
+    displayZone,
+    visibleInOffice: !["completed", "exited"].includes(status)
+  };
+}
+
+function toPublicSession(session) {
+  if (!session) {
+    return null;
+  }
+
+  const lifecycle = sessionLifecycle(session);
+  const meta = { ...(session.meta || {}) };
+  const runtime = {
+    pid: session.pid || null,
+    host: session.host || null,
+    transport: session.transport,
+    hasTerminal: ["pty", "tmux"].includes(session.transport),
+    tmuxSession: meta.tmuxSession || null,
+    attachCommand: meta.localAttachCommand || null
+  };
+
+  return {
+    contractVersion: CONTRACT_VERSION,
+    sessionId: session.sessionId,
+    provider: session.provider,
+    title: session.title,
+    command: session.command,
+    cwd: session.cwd,
+    mode: session.mode,
+    transport: session.transport,
+    state: lifecycle.state,
+    displayState: lifecycle.displayState,
+    displayZone: lifecycle.displayZone,
+    status: lifecycle.status,
+    visibleInOffice: lifecycle.visibleInOffice,
+    lifecycle,
+    timestamps: {
+      createdAt: session.createdAt,
+      updatedAt: session.updatedAt,
+      lastOutputAt: session.lastOutputAt || null
+    },
+    runtime,
+    createdAt: session.createdAt,
+    updatedAt: session.updatedAt,
+    lastOutputAt: session.lastOutputAt || null,
+    pid: runtime.pid,
+    host: runtime.host,
+    meta,
+    logs: [...(session.logs || [])],
+    events: [...(session.events || [])]
+  };
+}
+
+function toSessionSummary(session) {
+  const publicSession = toPublicSession(session);
+  if (!publicSession) {
+    return null;
+  }
+
+  return {
+    contractVersion: CONTRACT_VERSION,
+    sessionId: publicSession.sessionId,
+    provider: publicSession.provider,
+    title: publicSession.title,
+    mode: publicSession.mode,
+    transport: publicSession.transport,
+    state: publicSession.state,
+    displayState: publicSession.displayState,
+    displayZone: publicSession.displayZone,
+    status: publicSession.status,
+    visibleInOffice: publicSession.visibleInOffice,
+    lifecycle: publicSession.lifecycle,
+    timestamps: publicSession.timestamps,
+    runtime: {
+      host: publicSession.runtime.host,
+      hasTerminal: publicSession.runtime.hasTerminal
+    },
+    createdAt: publicSession.createdAt,
+    updatedAt: publicSession.updatedAt
+  };
+}
+
+module.exports = {
+  CONTRACT_VERSION,
+  toPublicSession,
+  toSessionSummary
+};

package/src/core/state.js

@@ -0,0 +1,23 @@
+const DISPLAY_STATES = {
+  IDLE: "idle",
+  WORKING: "working",
+  APPROVAL: "approval",
+  ATTENTION: "attention"
+};
+
+const DISPLAY_ZONES = {
+  idle: "idle-zone",
+  working: "working-zone",
+  approval: "approval-zone",
+  attention: "attention-zone"
+};
+
+function displayZoneFor(state) {
+  return DISPLAY_ZONES[state] || DISPLAY_ZONES.working;
+}
+
+module.exports = {
+  DISPLAY_STATES,
+  DISPLAY_ZONES,
+  displayZoneFor
+};

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

@@ -0,0 +1,232 @@
+const { EventEmitter } = require("node:events");
+const os = require("node:os");
+const crypto = require("node:crypto");
+const { LOG_LIMIT } = require("../config");
+const { displayZoneFor } = require("../state");
+const { toPublicSession, toSessionSummary } = require("../session-contract");
+
+function isoNow() {
+  return new Date().toISOString();
+}
+
+function cloneSession(session) {
+  return toPublicSession(session);
+}
+
+function applyState(session, nextState) {
+  session.state = nextState;
+  session.displayState = nextState;
+  session.displayZone = displayZoneFor(nextState);
+}
+
+function createSessionStore() {
+  const sessions = new Map();
+  const emitter = new EventEmitter();
+
+  function buildSession(payload) {
+    const sessionId = payload.sessionId || `sess_${crypto.randomBytes(5).toString("hex")}`;
+    const state = payload.state || "idle";
+    const createdAt = payload.createdAt || isoNow();
+    const updatedAt = payload.updatedAt || createdAt;
+
+    return {
+      sessionId,
+      provider: payload.provider || "generic",
+      title: payload.title || `${payload.provider || "worker"} session`,
+      command: payload.command || "",
+      cwd: payload.cwd || process.cwd(),
+      mode: payload.mode || "managed",
+      transport: payload.transport || "pty",
+      state,
+      displayState: payload.displayState || state,
+      displayZone: payload.displayZone || displayZoneFor(state),
+      status: payload.status || "registered",
+      createdAt,
+      updatedAt,
+      lastOutputAt: payload.lastOutputAt || null,
+      pid: payload.pid || null,
+      host: payload.host || os.hostname(),
+      meta: { ...(payload.meta || {}) },
+      logs: [...(payload.logs || [])],
+      events: [...(payload.events || [])]
+    };
+  }
+
+  function emitUpdate(sessionId) {
+    emitter.emit("session:update", getSession(sessionId));
+  }
+
+  function upsertSession(payload) {
+    const sessionId = payload.sessionId || `sess_${crypto.randomBytes(5).toString("hex")}`;
+    const existing = sessions.get(sessionId);
+
+    if (!existing) {
+      const created = buildSession({ ...payload, sessionId });
+      sessions.set(sessionId, created);
+      emitUpdate(sessionId);
+      return created;
+    }
+
+    Object.assign(existing, {
+      provider: payload.provider || existing.provider,
+      title: payload.title || existing.title,
+      command: payload.command || existing.command,
+      cwd: payload.cwd || existing.cwd,
+      mode: payload.mode || existing.mode,
+      transport: payload.transport || existing.transport,
+      pid: payload.pid === undefined ? existing.pid : payload.pid,
+      host: payload.host || existing.host,
+      meta: payload.meta ? { ...existing.meta, ...payload.meta } : existing.meta,
+      updatedAt: payload.updatedAt || isoNow()
+    });
+
+    if (payload.lastOutputAt !== undefined) {
+      existing.lastOutputAt = payload.lastOutputAt;
+    }
+    if (payload.state) {
+      applyState(existing, payload.state);
+    }
+    if (payload.displayState && !payload.state) {
+      existing.displayState = payload.displayState;
+    }
+    if (payload.displayZone && !payload.state) {
+      existing.displayZone = payload.displayZone;
+    }
+    if (payload.status) {
+      existing.status = payload.status;
+    }
+
+    emitUpdate(sessionId);
+    return existing;
+  }
+
+  function setSessionState(sessionId, nextState, patch = {}) {
+    const session = sessions.get(sessionId);
+    if (!session) {
+      return null;
+    }
+
+    applyState(session, nextState);
+    session.updatedAt = isoNow();
+    Object.assign(session, patch);
+    if (patch.displayState) {
+      session.displayState = patch.displayState;
+    }
+    if (patch.displayZone) {
+      session.displayZone = patch.displayZone;
+    }
+    emitUpdate(sessionId);
+    return session;
+  }
+
+  function addEvent(sessionId, eventName, patch = {}) {
+    const session = sessions.get(sessionId);
+    if (!session) {
+      return null;
+    }
+
+    session.events.push({
+      name: eventName,
+      state: session.state,
+      timestamp: isoNow(),
+      meta: patch.meta || {}
+    });
+    session.events = session.events.slice(-80);
+    session.updatedAt = isoNow();
+    emitUpdate(sessionId);
+    return session;
+  }
+
+  function appendOutput(sessionId, chunk) {
+    const session = sessions.get(sessionId);
+    if (!session) {
+      return null;
+    }
+
+    const lines = String(chunk).replace(/\r/g, "").split("\n").filter(Boolean);
+    session.logs.push(...lines);
+    session.logs = session.logs.slice(-LOG_LIMIT);
+    session.lastOutputAt = isoNow();
+    session.updatedAt = session.lastOutputAt;
+    // Terminal output does not change session state — skip session:update broadcast.
+    // Terminal data is forwarded directly by pty-manager via broadcastTerminal.
+    return session;
+  }
+
+  function markExit(sessionId, patch = {}) {
+    const session = sessions.get(sessionId);
+    if (!session) {
+      return null;
+    }
+
+    session.pid = null;
+    session.updatedAt = isoNow();
+    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;
+      }
+    }
+    emitUpdate(sessionId);
+    return session;
+  }
+
+  function getSession(sessionId) {
+    const session = sessions.get(sessionId);
+    return session ? cloneSession(session) : null;
+  }
+
+  function getSessionSummary(sessionId) {
+    const session = sessions.get(sessionId);
+    return session ? toSessionSummary(session) : null;
+  }
+
+  function listSessions() {
+    return [...sessions.values()]
+      .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
+      .map(cloneSession);
+  }
+
+  function listSessionSummaries() {
+    return [...sessions.values()]
+      .filter((session) => !["completed", "exited"].includes(session.status))
+      .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
+      .map((session) => toSessionSummary(session));
+  }
+
+  function removeSession(sessionId) {
+    const session = sessions.get(sessionId);
+    if (!session) {
+      return false;
+    }
+    sessions.delete(sessionId);
+    emitter.emit("session:remove", {
+      sessionId,
+      session: cloneSession(session)
+    });
+    return true;
+  }
+
+  return {
+    emitter,
+    upsertSession,
+    setSessionState,
+    addEvent,
+    appendOutput,
+    markExit,
+    getSession,
+    getSessionSummary,
+    listSessions,
+    listSessionSummaries,
+    removeSession
+  };
+}
+
+module.exports = {
+  createSessionStore
+};