codex-agent-view 0.4.6 → 0.4.8

package/src/core/monitor-store.mjs

@@ -232,6 +232,27 @@ function addActivity(session, event, status, limit) {
   }
 }
 
+function refineUnresolvedStartActivity(
+  session,
+  { type, idField, id, status },
+) {
+  const unresolvedStatuses = new Set([
+    "running",
+    "completion_not_observed",
+    "interrupted",
+  ]);
+  for (const activity of session.recent_activities) {
+    if (
+      activity.type === type &&
+      activity[idField] === id &&
+      unresolvedStatuses.has(activity.status)
+    ) {
+      activity.status = status;
+      break;
+    }
+  }
+}
+
 function applySessionEvent(session, event, limits) {
   const lifecycle = session.lifecycle;
   if (event.type === "session_started") {
@@ -377,6 +398,14 @@ function applySubagentEvent(session, event, limits) {
     agent.stopped_at_ms = event.received_at_ms;
     agent.status = agent.start_observed ? "stopped" : "stopped_without_start";
     agent.has_out_of_order_events = !agent.start_observed;
+    if (agent.start_observed) {
+      refineUnresolvedStartActivity(session, {
+        type: "subagent_started",
+        idField: "agent_id",
+        id: event.agent_id,
+        status: "stopped",
+      });
+    }
   }
 
   agent.agent_type = event.agent_type;
@@ -430,6 +459,14 @@ function applyToolEvent(session, event, limits) {
     tool.status = tool.start_observed ? "completed" : "completed_without_start";
     tool.has_out_of_order_events = !tool.start_observed;
     activityStatus = tool.status;
+    if (tool.start_observed) {
+      refineUnresolvedStartActivity(session, {
+        type: "tool_started",
+        idField: "tool_use_id",
+        id: event.tool_use_id,
+        status: "completed",
+      });
+    }
 
     const permission = session.permission;
     if (

package/src/runtime/server.mjs

@@ -1,6 +1,6 @@
 import { createServer } from "node:http";
 import { readFile } from "node:fs/promises";
-import { timingSafeEqual } from "node:crypto";
+import { createHmac, timingSafeEqual } from "node:crypto";
 import { fileURLToPath } from "node:url";
 
 import { createMonitorStore } from "../core/index.mjs";
@@ -29,6 +29,20 @@ const SECURITY_HEADERS = {
   "x-frame-options": "DENY",
 };
 
+const RECOVERY_HEADER = "x-codex-agent-view-recovery";
+const ACCESS_HEADER = "x-codex-agent-view-access";
+const BOOTSTRAP_SCOPE = "viewer_bootstrap";
+const RECOVERY_SCOPE = "viewer_recovery";
+const ACCESS_SCOPE = "viewer_access";
+const BOOTSTRAP_TTL_MS = 60 * 1_000;
+const RECOVERY_TTL_MS = 30 * 60 * 1_000;
+const ACCESS_TTL_MS = 15 * 60 * 1_000;
+const MAX_SIGNED_CREDENTIAL_LENGTH = 1_024;
+const MAX_USED_BOOTSTRAP_GRANTS = 256;
+const OWNERSHIP_PROOF_DOMAIN = "codex-agent-view/runtime-ownership/v1";
+const OWNERSHIP_NONCE_PATTERN = /^[A-Za-z0-9_-]{43}$/;
+const CANONICAL_SESSION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+
 function sendJson(response, statusCode, value, extraHeaders = {}) {
   response.writeHead(statusCode, {
     ...SECURITY_HEADERS,
@@ -38,14 +52,12 @@ function sendJson(response, statusCode, value, extraHeaders = {}) {
   response.end(`${JSON.stringify(value)}\n`);
 }
 
-function isLoopbackHostHeader(value) {
-  if (typeof value !== "string") {
-    return false;
-  }
-  const hostname = value.startsWith("[")
-    ? value.slice(1, value.indexOf("]"))
-    : value.split(":", 1)[0];
-  return hostname === LOOPBACK_HOST || hostname === "localhost" || hostname === "::1";
+function isOriginFormRequestTarget(value) {
+  return (
+    typeof value === "string" &&
+    /^\/(?!\/)/.test(value) &&
+    !value.includes("\\")
+  );
 }
 
 function hasToken(request, token) {
@@ -58,6 +70,120 @@ function hasToken(request, token) {
   return supplied.length === expected.length && timingSafeEqual(supplied, expected);
 }
 
+function signCredential(payload, signingToken) {
+  const encodedPayload = Buffer.from(JSON.stringify(payload)).toString("base64url");
+  const signature = createHmac("sha256", signingToken)
+    .update(encodedPayload)
+    .digest("base64url");
+  return `${encodedPayload}.${signature}`;
+}
+
+function createSignedCredential({
+  audience,
+  excludeSessionId = null,
+  grantId,
+  familyExpiresAtMs,
+  nowMs,
+  scope,
+  ttlMs,
+  signingToken,
+}) {
+  const expiresAtMs = Math.min(nowMs + ttlMs, familyExpiresAtMs);
+  const payload = {
+    aud: audience,
+    exclude_session_id: excludeSessionId,
+    exp: expiresAtMs,
+    family_exp: familyExpiresAtMs,
+    scope,
+    v: 1,
+  };
+  if (scope === BOOTSTRAP_SCOPE) {
+    payload.jti = grantId;
+  }
+  return {
+    credential: signCredential(payload, signingToken),
+    expiresAtMs,
+  };
+}
+
+function validateSignedCredential(
+  credential,
+  { audience, nowMs, scope, ttlMs, signingToken },
+) {
+  if (
+    typeof credential !== "string" ||
+    credential.length === 0 ||
+    credential.length > MAX_SIGNED_CREDENTIAL_LENGTH
+  ) {
+    return null;
+  }
+  const parts = credential.split(".");
+  if (parts.length !== 2 || !parts.every((part) => /^[A-Za-z0-9_-]+$/.test(part))) {
+    return null;
+  }
+  const [encodedPayload, suppliedSignature] = parts;
+  const expectedSignature = createHmac("sha256", signingToken)
+    .update(encodedPayload)
+    .digest("base64url");
+  const supplied = Buffer.from(suppliedSignature);
+  const expected = Buffer.from(expectedSignature);
+  if (supplied.length !== expected.length || !timingSafeEqual(supplied, expected)) {
+    return null;
+  }
+
+  let payload;
+  try {
+    payload = JSON.parse(Buffer.from(encodedPayload, "base64url").toString("utf8"));
+  } catch {
+    return null;
+  }
+  const expectedKeys = scope === BOOTSTRAP_SCOPE
+    ? "aud,exclude_session_id,exp,family_exp,jti,scope,v"
+    : "aud,exclude_session_id,exp,family_exp,scope,v";
+  if (
+    payload === null ||
+    typeof payload !== "object" ||
+    Array.isArray(payload) ||
+    Object.keys(payload).sort().join(",") !== expectedKeys ||
+    payload.v !== 1 ||
+    payload.scope !== scope ||
+    payload.aud !== audience ||
+    !(
+      payload.exclude_session_id === null ||
+      (
+        typeof payload.exclude_session_id === "string" &&
+        CANONICAL_SESSION_ID_PATTERN.test(payload.exclude_session_id)
+      )
+    ) ||
+    (scope === BOOTSTRAP_SCOPE && !/^[A-Za-z0-9_-]{43}$/.test(payload.jti)) ||
+    !Number.isSafeInteger(payload.exp) ||
+    !Number.isSafeInteger(payload.family_exp) ||
+    payload.exp <= nowMs ||
+    payload.exp > nowMs + ttlMs ||
+    payload.family_exp <= nowMs ||
+    payload.exp > payload.family_exp
+  ) {
+    return null;
+  }
+  return payload;
+}
+
+function createOwnershipProof(nonce, runtimeToken) {
+  return createHmac("sha256", runtimeToken)
+    .update(OWNERSHIP_PROOF_DOMAIN)
+    .update("\0")
+    .update(nonce)
+    .digest("base64url");
+}
+
+function bearerValue(request) {
+  const authorization = request.headers.authorization;
+  if (typeof authorization !== "string" || !authorization.startsWith("Bearer ")) {
+    return "";
+  }
+  return authorization.slice("Bearer ".length);
+}
+
 async function readJsonBody(request) {
   const chunks = [];
   let bytes = 0;
@@ -97,28 +223,259 @@ export async function startMonitorServer({
     throw new Error(`monitor server must bind to ${LOOPBACK_HOST}`);
   }
 
+  const usedBootstrapGrants = new Map();
   const server = createServer(async (request, response) => {
     try {
-      if (!isLoopbackHostHeader(request.headers.host)) {
-        sendJson(response, 421, { error: "loopback host required" });
+      const address = server.address();
+      if (address === null || typeof address === "string") {
+        sendJson(response, 503, { error: "monitor unavailable" });
+        return;
+      }
+      const audience = `http://${LOOPBACK_HOST}:${address.port}`;
+      const exactHost = `${LOOPBACK_HOST}:${address.port}`;
+      if (
+        request.headers.host !== exactHost ||
+        !isOriginFormRequestTarget(request.url)
+      ) {
+        sendJson(response, 421, { error: "exact monitor authority required" });
         return;
       }
 
-      const requestUrl = new URL(request.url || "/", `http://${LOOPBACK_HOST}`);
+      const requestUrl = new URL(request.url, audience);
+      const nowMs = now();
       if (request.method === "GET" && requestUrl.pathname === "/api/health") {
         sendJson(response, 200, { ok: true });
         return;
       }
 
+      if (
+        request.method === "POST" &&
+        requestUrl.pathname === "/api/internal/ownership-proof"
+      ) {
+        if (request.headers["content-type"] !== "application/json") {
+          sendJson(response, 415, { error: "application/json required" });
+          return;
+        }
+        const payload = await readJsonBody(request);
+        if (
+          payload === null ||
+          typeof payload !== "object" ||
+          Array.isArray(payload) ||
+          Object.keys(payload).join(",") !== "nonce" ||
+          !OWNERSHIP_NONCE_PATTERN.test(payload.nonce)
+        ) {
+          sendJson(response, 400, { error: "invalid ownership challenge" });
+          return;
+        }
+        sendJson(response, 200, {
+          proof: createOwnershipProof(payload.nonce, token),
+          status: "owned",
+        });
+        return;
+      }
+
+      if (
+        request.method === "POST" &&
+        requestUrl.pathname === "/api/internal/viewer-grant"
+      ) {
+        if (!hasToken(request, token)) {
+          sendJson(response, 401, { error: "authorization required" });
+          return;
+        }
+        if (request.headers["content-type"] !== "application/json") {
+          sendJson(response, 415, { error: "application/json required" });
+          return;
+        }
+        const payload = await readJsonBody(request);
+        if (
+          payload === null ||
+          typeof payload !== "object" ||
+          Array.isArray(payload) ||
+          Object.keys(payload).join(",") !== "exclude_session_id" ||
+          !(
+            payload.exclude_session_id === null ||
+            (
+              typeof payload.exclude_session_id === "string" &&
+              CANONICAL_SESSION_ID_PATTERN.test(payload.exclude_session_id)
+            )
+          )
+        ) {
+          sendJson(response, 400, { error: "invalid viewer grant request" });
+          return;
+        }
+        const familyExpiresAtMs = nowMs + RECOVERY_TTL_MS;
+        const bootstrap = createSignedCredential({
+          audience,
+          excludeSessionId: payload.exclude_session_id,
+          familyExpiresAtMs,
+          grantId: createRuntimeToken(),
+          nowMs,
+          scope: BOOTSTRAP_SCOPE,
+          ttlMs: BOOTSTRAP_TTL_MS,
+          signingToken: token,
+        });
+        sendJson(response, 201, {
+          bootstrap_credential: bootstrap.credential,
+          expires_in_ms: BOOTSTRAP_TTL_MS,
+          status: "granted",
+        });
+        return;
+      }
+
       if (
         request.method === "GET" &&
         requestUrl.pathname === "/api/state"
       ) {
-        if (!hasToken(request, token) && !hasToken(request, viewerToken)) {
+        const suppliedBearer = bearerValue(request);
+        const accessPayload = validateSignedCredential(suppliedBearer, {
+          audience,
+          nowMs,
+          scope: ACCESS_SCOPE,
+          ttlMs: ACCESS_TTL_MS,
+          signingToken: viewerToken,
+        });
+        const runtimeAuthorized = hasToken(request, token);
+        const rootViewerAuthorized = hasToken(request, viewerToken);
+        if (
+          !runtimeAuthorized &&
+          !rootViewerAuthorized &&
+          !accessPayload
+        ) {
           sendJson(response, 401, { error: "authorization required" });
           return;
         }
-        sendJson(response, 200, store.getSnapshot());
+        const requestedExclusion = request.headers["x-codex-agent-view-exclude-session"];
+        const excludeSessionId = accessPayload?.exclude_session_id ?? (
+          rootViewerAuthorized &&
+          typeof requestedExclusion === "string" &&
+          CANONICAL_SESSION_ID_PATTERN.test(requestedExclusion)
+            ? requestedExclusion
+            : null
+        );
+        const extraHeaders = {};
+        if (rootViewerAuthorized || accessPayload) {
+          const familyExpiresAtMs = accessPayload?.family_exp ?? (
+            nowMs + RECOVERY_TTL_MS
+          );
+          const access = createSignedCredential({
+            audience,
+            excludeSessionId,
+            familyExpiresAtMs,
+            nowMs,
+            scope: ACCESS_SCOPE,
+            ttlMs: ACCESS_TTL_MS,
+            signingToken: viewerToken,
+          });
+          extraHeaders[ACCESS_HEADER] = access.credential;
+        }
+        if (rootViewerAuthorized) {
+          const familyExpiresAtMs = nowMs + RECOVERY_TTL_MS;
+          const recovery = createSignedCredential({
+            audience,
+            excludeSessionId,
+            familyExpiresAtMs,
+            nowMs,
+            scope: RECOVERY_SCOPE,
+            ttlMs: RECOVERY_TTL_MS,
+            signingToken: viewerToken,
+          });
+          extraHeaders[RECOVERY_HEADER] = recovery.credential;
+        }
+        sendJson(response, 200, store.getSnapshot(), {
+          ...extraHeaders,
+        });
+        return;
+      }
+
+      if (
+        request.method === "POST" &&
+        requestUrl.pathname === "/api/viewer/exchange"
+      ) {
+        if (
+          request.headers.origin !== audience ||
+          (
+            request.headers["sec-fetch-site"] !== undefined &&
+            request.headers["sec-fetch-site"] !== "same-origin"
+          )
+        ) {
+          sendJson(response, 403, { error: "same-origin request required" });
+          return;
+        }
+        if (request.headers["content-type"] !== "application/json") {
+          sendJson(response, 415, { error: "application/json required" });
+          return;
+        }
+        const payload = await readJsonBody(request);
+        const exactPayload =
+          payload === null ||
+          typeof payload !== "object" ||
+          Array.isArray(payload) ||
+          Object.keys(payload).join(",") !== "credential";
+        const bootstrapPayload = exactPayload ? null : validateSignedCredential(
+          payload.credential,
+          {
+            audience,
+            nowMs,
+            scope: BOOTSTRAP_SCOPE,
+            ttlMs: BOOTSTRAP_TTL_MS,
+            signingToken: token,
+          },
+        );
+        const recoveryPayload = exactPayload || bootstrapPayload
+          ? null
+          : validateSignedCredential(payload.credential, {
+            audience,
+            nowMs,
+            scope: RECOVERY_SCOPE,
+            ttlMs: RECOVERY_TTL_MS,
+            signingToken: viewerToken,
+          });
+        const credentialPayload = bootstrapPayload || recoveryPayload;
+        if (!credentialPayload) {
+          sendJson(response, 401, { error: "viewer exchange authorization required" });
+          return;
+        }
+        if (bootstrapPayload) {
+          for (const [grantId, expiresAtMs] of usedBootstrapGrants) {
+            if (expiresAtMs <= nowMs) usedBootstrapGrants.delete(grantId);
+          }
+          if (usedBootstrapGrants.has(bootstrapPayload.jti)) {
+            sendJson(response, 409, { error: "viewer grant already used" });
+            return;
+          }
+          if (usedBootstrapGrants.size >= MAX_USED_BOOTSTRAP_GRANTS) {
+            sendJson(response, 503, { error: "viewer grant capacity reached" });
+            return;
+          }
+          usedBootstrapGrants.set(bootstrapPayload.jti, bootstrapPayload.exp);
+        }
+        const excludeSessionId = credentialPayload.exclude_session_id;
+        const access = createSignedCredential({
+          audience,
+          excludeSessionId,
+          familyExpiresAtMs: credentialPayload.family_exp,
+          nowMs,
+          scope: ACCESS_SCOPE,
+          ttlMs: ACCESS_TTL_MS,
+          signingToken: viewerToken,
+        });
+        const recovery = createSignedCredential({
+          audience,
+          excludeSessionId,
+          familyExpiresAtMs: credentialPayload.family_exp,
+          nowMs,
+          scope: RECOVERY_SCOPE,
+          ttlMs: RECOVERY_TTL_MS,
+          signingToken: viewerToken,
+        });
+        sendJson(response, 200, {
+          access_credential: access.credential,
+          access_expires_in_ms: access.expiresAtMs - nowMs,
+          excluded_session_id: excludeSessionId,
+          recovery_credential: recovery.credential,
+          recovery_expires_in_ms: recovery.expiresAtMs - nowMs,
+          status: "exchanged",
+        });
         return;
       }