codex-agent-view 0.4.4 → 0.4.6

package/src/core/monitor-store.mjs

@@ -5,6 +5,7 @@ const DEFAULT_LIMITS = Object.freeze({
   maxAgentsPerSession: 100,
   maxDiagnostics: 100,
   maxSessions: 50,
+  staleAfterMs: 5 * 60 * 1000,
 });
 
 function positiveInteger(value, name) {
@@ -19,6 +20,8 @@ function createSession(event) {
     session_id: event.session_id,
     workspace_label: null,
     workspace_label_observed_at_ms: null,
+    task_summary: null,
+    task_summary_observed_at_ms: null,
     first_seen_at_ms: event.received_at_ms,
     last_seen_at_ms: event.received_at_ms,
     agents: new Map(),
@@ -42,6 +45,22 @@ function createSession(event) {
   };
 }
 
+function applyTaskSummary(session, event) {
+  if (event.type !== "turn_started") {
+    return;
+  }
+  if (
+    session.task_summary_observed_at_ms !== null &&
+    event.received_at_ms < session.task_summary_observed_at_ms
+  ) {
+    return;
+  }
+  session.task_summary_observed_at_ms = event.received_at_ms;
+  if (session.task_summary === null && "task_summary" in event) {
+    session.task_summary = event.task_summary;
+  }
+}
+
 function applyWorkspaceLabel(session, event) {
   if (!("workspace_label" in event)) {
     return;
@@ -56,7 +75,30 @@ function applyWorkspaceLabel(session, event) {
   session.workspace_label_observed_at_ms = event.received_at_ms;
 }
 
-function deriveSessionStatus(session) {
+function hasActiveState(session) {
+  return (
+    session.permission.status === "waiting_for_user" ||
+    session.root_turn.status === "running" ||
+    [...session.agents.values()].some(({ status }) => status === "running") ||
+    [...session.tools.values()].some(({ status }) => status === "running")
+  );
+}
+
+function isStaleActiveSession(session, nowMs, staleAfterMs) {
+  return (
+    !session.lifecycle.end_observed &&
+    hasActiveState(session) &&
+    nowMs - session.last_seen_at_ms >= staleAfterMs
+  );
+}
+
+function deriveSessionStatus(session, nowMs, staleAfterMs) {
+  if (session.lifecycle.end_observed) {
+    return "completed";
+  }
+  if (isStaleActiveSession(session, nowMs, staleAfterMs)) {
+    return "completion_not_observed";
+  }
   if (session.permission.status === "waiting_for_user") {
     return "waiting_for_user";
   }
@@ -67,12 +109,92 @@ function deriveSessionStatus(session) {
   ) {
     return "running";
   }
-  if (session.lifecycle.end_observed) {
+  if (session.root_turn.status === "completed") {
     return "completed";
   }
   return "observed";
 }
 
+function settleRunningState(session, status, options = {}) {
+  const turnId = options.turnId;
+  const settledAgentIds = new Set();
+  const settledToolUseIds = new Set();
+  for (const agent of session.agents.values()) {
+    if (
+      agent.status === "running" &&
+      (turnId === undefined || agent.turn_id === turnId)
+    ) {
+      agent.status = status;
+      settledAgentIds.add(agent.agent_id);
+    }
+  }
+  for (const tool of session.tools.values()) {
+    if (
+      tool.status === "running" &&
+      (turnId === undefined || tool.turn_id === turnId)
+    ) {
+      tool.status = status;
+      settledToolUseIds.add(tool.tool_use_id);
+    }
+  }
+  for (const activity of session.recent_activities) {
+    if (
+      activity.status === "running" &&
+      ((activity.type === "subagent_started" &&
+        settledAgentIds.has(activity.agent_id)) ||
+        (activity.type === "tool_started" &&
+          settledToolUseIds.has(activity.tool_use_id)))
+    ) {
+      activity.status = status;
+    }
+  }
+}
+
+function clearPermission(session, activityStatus) {
+  const permission = session.permission;
+  if (permission.status !== "waiting_for_user") {
+    return;
+  }
+  for (const activity of session.recent_activities) {
+    if (
+      activity.type === "permission_requested" &&
+      activity.status === "waiting_for_user" &&
+      activity.turn_id === permission.turn_id &&
+      activity.tool_name === permission.tool_name
+    ) {
+      activity.status = activityStatus;
+      break;
+    }
+  }
+  session.permission = { status: "idle" };
+}
+
+function settleRootTurnActivity(session, status) {
+  for (const activity of session.recent_activities) {
+    if (
+      activity.type === "turn_started" &&
+      activity.status === "running" &&
+      activity.turn_id === session.root_turn.turn_id
+    ) {
+      activity.status = status;
+      break;
+    }
+  }
+}
+
+function resetTransientState(session) {
+  session.agents.clear();
+  session.tools.clear();
+  session.root_turn = {
+    status: "idle",
+    turn_id: null,
+    started_at_ms: null,
+    stopped_at_ms: null,
+    has_out_of_order_events: false,
+  };
+  session.permission = { status: "idle" };
+}
+
 function touchMapEntry(map, key, value) {
   map.delete(key);
   map.set(key, value);
@@ -91,7 +213,14 @@ function addActivity(session, event, status, limit) {
     received_at_ms: event.received_at_ms,
   };
 
-  for (const field of ["turn_id", "agent_id", "agent_type", "tool_name", "tool_use_id"]) {
+  for (const field of [
+    "turn_id",
+    "agent_id",
+    "agent_type",
+    "tool_name",
+    "tool_use_id",
+    "session_start_source",
+  ]) {
     if (field in event) {
       activity[field] = event[field];
     }
@@ -107,11 +236,35 @@ function applySessionEvent(session, event, limits) {
   const lifecycle = session.lifecycle;
   if (event.type === "session_started") {
     const resumedAfterEnd = lifecycle.end_observed;
+    const startsNewEpoch =
+      resumedAfterEnd ||
+      event.session_start_source === "resume" ||
+      event.session_start_source === "clear";
+    if (event.session_start_source === "compact") {
+      if (resumedAfterEnd) {
+        return "stale";
+      }
+      lifecycle.start_observed = true;
+      lifecycle.started_at_ms ??= event.received_at_ms;
+      addActivity(session, event, "observed", limits.maxActivitiesPerSession);
+      return "applied";
+    }
+    if (lifecycle.start_observed && !startsNewEpoch) {
+      return "duplicate";
+    }
+    if (startsNewEpoch) {
+      if (!resumedAfterEnd) {
+        settleRootTurnActivity(session, "completion_not_observed");
+        clearPermission(session, "completion_not_observed");
+        settleRunningState(session, "completion_not_observed");
+      }
+      resetTransientState(session);
+    }
     lifecycle.start_observed = true;
-    lifecycle.started_at_ms ??= event.received_at_ms;
+    lifecycle.started_at_ms = event.received_at_ms;
     lifecycle.end_observed = false;
     lifecycle.ended_at_ms = null;
-    lifecycle.has_out_of_order_events ||= resumedAfterEnd;
+    lifecycle.has_out_of_order_events = false;
     addActivity(session, event, "observed", limits.maxActivitiesPerSession);
     return "applied";
   }
@@ -122,9 +275,11 @@ function applySessionEvent(session, event, limits) {
   lifecycle.end_observed = true;
   lifecycle.ended_at_ms = event.received_at_ms;
   lifecycle.has_out_of_order_events = !lifecycle.start_observed;
+  settleRootTurnActivity(session, "completed");
   session.root_turn.status = "completed";
   session.root_turn.stopped_at_ms ??= event.received_at_ms;
-  session.permission = { status: "idle" };
+  clearPermission(session, "interrupted");
+  settleRunningState(session, "interrupted");
   addActivity(session, event, "completed", limits.maxActivitiesPerSession);
   return "applied";
 }
@@ -132,9 +287,10 @@ function applySessionEvent(session, event, limits) {
 function applyTurnEvent(session, event, limits) {
   const turn = session.root_turn;
   if (event.type === "turn_started") {
-    if (turn.turn_id === event.turn_id && turn.status === "running") {
-      return "duplicate";
+    if (turn.turn_id === event.turn_id) {
+      return turn.status === "running" ? "duplicate" : "stale";
     }
+    settleRunningState(session, "completion_not_observed");
     session.root_turn = {
       status: "running",
       turn_id: event.turn_id,
@@ -142,7 +298,12 @@ function applyTurnEvent(session, event, limits) {
       stopped_at_ms: null,
       has_out_of_order_events: false,
     };
-    session.permission = { status: "idle" };
+    if (
+      session.permission.status !== "waiting_for_user" ||
+      session.permission.turn_id !== event.turn_id
+    ) {
+      clearPermission(session, "completion_not_observed");
+    }
     addActivity(session, event, "running", limits.maxActivitiesPerSession);
     return "applied";
   }
@@ -151,6 +312,9 @@ function applyTurnEvent(session, event, limits) {
     return "duplicate";
   }
   const startObserved = turn.turn_id === event.turn_id && turn.started_at_ms !== null;
+  if (startObserved) {
+    settleRootTurnActivity(session, "completed");
+  }
   session.root_turn = {
     status: "completed",
     turn_id: event.turn_id,
@@ -158,7 +322,15 @@ function applyTurnEvent(session, event, limits) {
     stopped_at_ms: event.received_at_ms,
     has_out_of_order_events: !startObserved,
   };
-  session.permission = { status: "idle" };
+  if (
+    session.permission.status === "waiting_for_user" &&
+    session.permission.turn_id === event.turn_id
+  ) {
+    clearPermission(session, "completion_not_observed");
+  }
+  settleRunningState(session, "completion_not_observed", {
+    turnId: event.turn_id,
+  });
   addActivity(
     session,
     event,
@@ -174,6 +346,7 @@ function applySubagentEvent(session, event, limits) {
     agent = {
       agent_id: event.agent_id,
       agent_type: event.agent_type,
+      turn_id: event.turn_id,
       status: "unknown",
       started_at_ms: null,
       stopped_at_ms: null,
@@ -207,6 +380,7 @@ function applySubagentEvent(session, event, limits) {
   }
 
   agent.agent_type = event.agent_type;
+  agent.turn_id = event.turn_id;
   agent.last_seen_at_ms = Math.max(agent.last_seen_at_ms, event.received_at_ms);
   touchMapEntry(session.agents, event.agent_id, agent);
   trimMap(session.agents, limits.maxAgentsPerSession);
@@ -264,7 +438,7 @@ function applyToolEvent(session, event, limits) {
       permission.turn_id === event.turn_id &&
       event.received_at_ms >= permission.requested_at_ms
     ) {
-      session.permission = { status: "idle" };
+      clearPermission(session, "completed");
     }
   }
 
@@ -310,9 +484,29 @@ function applyPermissionEvent(session, event, limits) {
 }
 
 function applyEvent(session, event, limits) {
-  if (event.type === "session_started" || event.type === "session_ended") {
+  if (event.type === "session_started") {
+    return applySessionEvent(session, event, limits);
+  }
+  if (
+    session.lifecycle.end_observed &&
+    event.type !== "tool_completed" &&
+    event.type !== "subagent_stopped"
+  ) {
+    return event.type === "session_ended" ? "duplicate" : "stale";
+  }
+  if (event.type === "session_ended") {
     return applySessionEvent(session, event, limits);
   }
+  if (
+    session.root_turn.status === "completed" &&
+    session.root_turn.turn_id === event.turn_id &&
+    (event.type === "turn_started" ||
+      event.type === "permission_requested" ||
+      event.type === "tool_started" ||
+      event.type === "subagent_started")
+  ) {
+    return "stale";
+  }
   if (event.type === "turn_started" || event.type === "turn_stopped") {
     return applyTurnEvent(session, event, limits);
   }
@@ -325,21 +519,51 @@ function applyEvent(session, event, limits) {
   return applyPermissionEvent(session, event, limits);
 }
 
-function snapshotSession(session) {
+function snapshotSession(session, nowMs, staleAfterMs) {
+  const staleActive = isStaleActiveSession(session, nowMs, staleAfterMs);
   return {
     session_id: session.session_id,
     workspace_label: session.workspace_label,
-    status: deriveSessionStatus(session),
+    task_summary: session.task_summary,
+    status: deriveSessionStatus(session, nowMs, staleAfterMs),
     first_seen_at_ms: session.first_seen_at_ms,
     last_seen_at_ms: session.last_seen_at_ms,
     agents: [...session.agents.values()]
-      .map(({ start_observed, stop_observed, ...agent }) => ({ ...agent }))
+      .map(({ start_observed, stop_observed, ...agent }) => ({
+        ...agent,
+        ...(staleActive && agent.status === "running"
+          ? { status: "completion_not_observed" }
+          : {}),
+      }))
       .sort((left, right) => right.last_seen_at_ms - left.last_seen_at_ms),
-    root_turn: { ...session.root_turn },
+    tools: [...session.tools.values()]
+      .map(({ start_observed, completion_observed, ...tool }) => ({
+        ...tool,
+        ...(staleActive && tool.status === "running"
+          ? { status: "completion_not_observed" }
+          : {}),
+      }))
+      .sort((left, right) => right.last_seen_at_ms - left.last_seen_at_ms),
+    root_turn: {
+      ...session.root_turn,
+      ...(staleActive && session.root_turn.status === "running"
+        ? { status: "completion_not_observed" }
+        : {}),
+    },
     recent_activities: session.recent_activities.map((activity) => ({
       ...activity,
+      ...(staleActive &&
+      (activity.status === "running" ||
+        activity.status === "waiting_for_user")
+        ? { status: "completion_not_observed" }
+        : {}),
     })),
-    permission: { ...session.permission },
+    permission: {
+      ...session.permission,
+      ...(staleActive && session.permission.status === "waiting_for_user"
+        ? { status: "completion_not_observed" }
+        : {}),
+    },
   };
 }
 
@@ -362,6 +586,10 @@ export function createMonitorStore(options = {}) {
       options.maxSessions ?? DEFAULT_LIMITS.maxSessions,
       "maxSessions",
     ),
+    staleAfterMs: positiveInteger(
+      options.staleAfterMs ?? DEFAULT_LIMITS.staleAfterMs,
+      "staleAfterMs",
+    ),
   };
   const now = options.now ?? Date.now;
   if (typeof now !== "function") {
@@ -409,6 +637,7 @@ export function createMonitorStore(options = {}) {
     }
 
     applyWorkspaceLabel(session, event);
+    applyTaskSummary(session, event);
 
     session.first_seen_at_ms = Math.min(
       session.first_seen_at_ms,
@@ -425,12 +654,15 @@ export function createMonitorStore(options = {}) {
   }
 
   function getSnapshot() {
+    const snapshotAtMs = now();
     return {
       schema_version: 1,
       source_of_truth: "hook",
       updated_at_ms: updatedAtMs,
       sessions: [...sessions.values()]
-        .map(snapshotSession)
+        .map((session) =>
+          snapshotSession(session, snapshotAtMs, limits.staleAfterMs),
+        )
         .sort((left, right) => right.last_seen_at_ms - left.last_seen_at_ms),
       diagnostics: diagnostics.map((diagnostic) => ({ ...diagnostic })),
     };

package/src/core/normalize-hook-payload.mjs

@@ -11,11 +11,38 @@ const NORMALIZED_EVENT_TYPES = Object.freeze({
 });
 
 const SESSION_EVENT_TYPES = new Set(["session_started", "session_ended"]);
+const SESSION_START_SOURCES = new Set([
+  "startup",
+  "resume",
+  "clear",
+  "compact",
+]);
 
 const MAX_IDENTIFIER_LENGTH = 512;
 const MAX_LABEL_LENGTH = 256;
 const MAX_WORKSPACE_LABEL_LENGTH = 120;
+const MAX_PROMPT_INSPECTION_LENGTH = 4_096;
+const MAX_TASK_SUMMARY_LENGTH = 180;
 const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f]/;
+const CONTROL_CHARACTERS_GLOBAL = /[\u0000-\u001f\u007f-\u009f]/g;
+
+const URL =
+  /\b[A-Z][A-Z0-9+.-]*:\/\/[^\s<>"'`]+|\bwww\.[^\s<>"'`]+/giu;
+const EMAIL = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/giu;
+const LABELED_CREDENTIAL =
+  /\b(?:[A-Z0-9]+[_-])*(?:api[_-]?key|access[_-]?token|auth(?:orization)?|bearer|credential|key|password|passwd|private[_-]?key|refresh[_-]?token|secret|token)\b\s*(?:=|:)\s*(?:"[^"\r\n]*"|'[^'\r\n]*'|[^\s,;]+)/giu;
+const BEARER_CREDENTIAL = /\bBearer\s+[A-Za-z0-9._~+\/-]+=*/giu;
+const PREFIXED_SECRET =
+  /\b(?:AKIA[0-9A-Z]{16}|AIza[A-Za-z0-9_-]{20,}|github_pat_[A-Za-z0-9_]{12,}|gh[pousr]_[A-Za-z0-9_]{12,}|glpat-[A-Za-z0-9_-]{12,}|npm_[A-Za-z0-9_]{12,}|sk-[A-Za-z0-9_-]{12,}|(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{12,}|whsec_[A-Za-z0-9]{12,}|xox[baprs]-[A-Za-z0-9-]{12,})\b/gu;
+const JWT = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/gu;
+const PRIVATE_KEY_BLOCK =
+  /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z0-9 ]*PRIVATE KEY-----|$)/giu;
+const WINDOWS_ABSOLUTE_PATH =
+  /(^|[\s("'`=:[{])[A-Za-z]:[\\/][^\s<>"'`)\]},;]*/gu;
+const UNC_ABSOLUTE_PATH =
+  /(^|[\s("'`=:[{])\\\\[^\s<>"'`)\]},;]+(?:\\[^\s<>"'`)\]},;]+)+/gu;
+const POSIX_ABSOLUTE_PATH =
+  /(^|[\s("'`=:[{])\/(?!\/)[^\s<>"'`)\]},;]*(?:\/[^\s<>"'`)\]},;]+)*/gu;
 
 function isObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -86,6 +113,52 @@ function optionalWorkspaceLabel(payload) {
   return label;
 }
 
+function replaceAbsolutePaths(value) {
+  return value
+    .replace(UNC_ABSOLUTE_PATH, (_match, prefix) => `${prefix}[path]`)
+    .replace(WINDOWS_ABSOLUTE_PATH, (_match, prefix) => `${prefix}[path]`)
+    .replace(POSIX_ABSOLUTE_PATH, (_match, prefix) => `${prefix}[path]`);
+}
+
+/**
+ * Derive a short, display-safe hint from an untrusted UserPromptSubmit prompt.
+ * The caller must discard the raw prompt after this synchronous derivation.
+ */
+export function deriveTaskSummary(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+
+  let summary = value
+    .slice(0, MAX_PROMPT_INSPECTION_LENGTH)
+    .replace(PRIVATE_KEY_BLOCK, "[credential]")
+    .replace(CONTROL_CHARACTERS_GLOBAL, " ")
+    .replace(URL, "[link]")
+    .replace(EMAIL, "[email]")
+    .replace(LABELED_CREDENTIAL, "[credential]")
+    .replace(BEARER_CREDENTIAL, "[credential]")
+    .replace(PREFIXED_SECRET, "[credential]")
+    .replace(JWT, "[credential]");
+  summary = replaceAbsolutePaths(summary).replace(/\s+/gu, " ").trim();
+
+  if (!summary || !summary.replace(/\[(?:credential|email|link|path)\]/gu, "").trim()) {
+    return null;
+  }
+
+  const characters = Array.from(summary);
+  if (characters.length <= MAX_TASK_SUMMARY_LENGTH) {
+    return summary;
+  }
+
+  const bounded = characters
+    .slice(0, MAX_TASK_SUMMARY_LENGTH - 1)
+    .join("")
+    .trimEnd();
+  const lastSpace = bounded.lastIndexOf(" ");
+  const readableBoundary = lastSpace >= Math.floor(MAX_TASK_SUMMARY_LENGTH * 0.6);
+  return `${readableBoundary ? bounded.slice(0, lastSpace) : bounded}…`;
+}
+
 /**
  * Validate an untrusted Codex hook payload and retain only monitor-safe fields.
  * Raw prompts, tool input/output, paths, and assistant messages are never copied.
@@ -122,11 +195,29 @@ export function normalizeHookPayload(payload, options = {}) {
   }
 
   const event = commonEvent(payload, type, receivedAtMs);
+  if (
+    type === "session_started" &&
+    typeof payload.source === "string" &&
+    SESSION_START_SOURCES.has(payload.source)
+  ) {
+    event.session_start_source = payload.source;
+  }
   const workspaceLabel = optionalWorkspaceLabel(payload);
   if (workspaceLabel) {
     event.workspace_label = workspaceLabel;
   }
 
+  if (type === "turn_started") {
+    const taskSummary = deriveTaskSummary(
+      typeof payload.task_summary === "string"
+        ? payload.task_summary
+        : payload.prompt,
+    );
+    if (taskSummary) {
+      event.task_summary = taskSummary;
+    }
+  }
+
   if (type === "subagent_started" || type === "subagent_stopped") {
     for (const [field, maxLength] of [
       ["agent_id", MAX_IDENTIFIER_LENGTH],