npm - remote-codex - Versions diffs - 0.11.40 → 0.11.42 - Mend

remote-codex 0.11.40 → 0.11.42

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/apps/relay-server/dist/index.js +136 -49
package/apps/supervisor-api/dist/index.js +166 -20
package/apps/supervisor-web/dist/assets/index-BcCLYWAf.css +1 -0
package/apps/supervisor-web/dist/assets/index-BvxWpPKW.js +21 -0
package/apps/supervisor-web/dist/assets/{thread-ui-xWvswa2v.js → thread-ui-BLThton-.js} +40 -38
package/apps/supervisor-web/dist/index.html +3 -3
package/package.json +1 -1
package/packages/claude/src/runtimeAdapter.test.ts +135 -0
package/packages/claude/src/runtimeAdapter.ts +156 -5
package/packages/shared/src/index.ts +91 -1
package/apps/supervisor-web/dist/assets/index-B-qj7e8G.js +0 -21
package/apps/supervisor-web/dist/assets/index-CDFuOeJN.css +0 -1

package/apps/supervisor-web/dist/index.html CHANGED Viewed

@@ -10,16 +10,16 @@
     <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png" />
     <link rel="manifest" href="/site.webmanifest" />
     <title>Remote Codex</title>
-    <script type="module" crossorigin src="/assets/index-B-qj7e8G.js"></script>
+    <script type="module" crossorigin src="/assets/index-BvxWpPKW.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/react-vendor-Dfg_6BLf.js">
     <link rel="modulepreload" crossorigin href="/assets/ui-vendor-CuR8GHb0.js">
     <link rel="modulepreload" crossorigin href="/assets/graph-vendor-DVQUpZ8C.js">
     <link rel="modulepreload" crossorigin href="/assets/terminal-vendor-C5bTa-Ka.js">
     <link rel="modulepreload" crossorigin href="/assets/markdown-vendor-RZk8L7-L.js">
-    <link rel="modulepreload" crossorigin href="/assets/thread-ui-xWvswa2v.js">
+    <link rel="modulepreload" crossorigin href="/assets/thread-ui-BLThton-.js">
     <link rel="stylesheet" crossorigin href="/assets/graph-vendor-C5ap-Sga.css">
     <link rel="stylesheet" crossorigin href="/assets/terminal-vendor-Beg8tuEN.css">
-    <link rel="stylesheet" crossorigin href="/assets/index-CDFuOeJN.css">
+    <link rel="stylesheet" crossorigin href="/assets/index-BcCLYWAf.css">
   </head>
   <body class="bg-stone-950">
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "remote-codex",
-  "version": "0.11.40",
+  "version": "0.11.42",
   "description": "Local web supervisor for Codex workspaces and threads.",
   "license": "MIT",
   "type": "module",

package/packages/claude/src/runtimeAdapter.test.ts CHANGED Viewed

@@ -2983,4 +2983,139 @@ describe('ClaudeRuntimeAdapter', () => {
       ]),
     );
   });
+  it('keeps live Claude compaction in the active turn and hides its summary', async () => {
+    const adapter = makeAdapter((prompt) => prompt === hiddenInitPrompt()
+      ? [systemInit(), result()]
+      : [
+          systemInit(),
+          {
+            type: 'assistant',
+            uuid: 'assistant-before-compact',
+            session_id: 'claude-session-1',
+            message: { role: 'assistant', content: [{ type: 'text', text: 'Before.' }] },
+            parent_tool_use_id: null,
+          },
+          {
+            type: 'system',
+            subtype: 'status',
+            status: 'compacting',
+            uuid: 'compact-status',
+            session_id: 'claude-session-1',
+          },
+          {
+            type: 'user',
+            uuid: 'compact-summary',
+            session_id: 'claude-session-1',
+            isCompactSummary: true,
+            message: { role: 'user', content: 'HIDDEN LIVE SUMMARY' },
+            parent_tool_use_id: null,
+          },
+          {
+            type: 'system',
+            subtype: 'compact_boundary',
+            compact_metadata: { trigger: 'auto', pre_tokens: 180_000 },
+            uuid: 'compact-boundary',
+            session_id: 'claude-session-1',
+          },
+          {
+            type: 'assistant',
+            uuid: 'assistant-after-compact',
+            session_id: 'claude-session-1',
+            message: { role: 'assistant', content: [{ type: 'text', text: 'After.' }] },
+            parent_tool_use_id: null,
+          },
+          result(),
+        ]);
+    const events: AgentRuntimeEvent[] = [];
+    adapter.on('event', (event) => events.push(event));
+    await adapter.startTurn({
+      providerSessionId: 'claude-session-1',
+      displayTurnId: 'turn-compact',
+      prompt: 'Continue working',
+    } as any);
+    await wait();
+    const completed = events.findLast((event) => event.type === 'turn.completed');
+    const items = completed?.type === 'turn.completed' ? completed.turn.items : [];
+    expect(completed).toMatchObject({
+      type: 'turn.completed',
+      turn: { providerTurnId: 'turn-compact', status: 'completed' },
+    });
+    expect(items.filter((item) => item.kind === 'contextCompaction')).toEqual([
+      expect.objectContaining({
+        text: 'Context compacted',
+        detailText: null,
+        status: 'completed',
+      }),
+    ]);
+    expect(items).toEqual(expect.arrayContaining([
+      expect.objectContaining({ kind: 'agentMessage', text: 'Before.' }),
+      expect.objectContaining({ kind: 'agentMessage', text: 'After.' }),
+    ]));
+    expect(JSON.stringify(items)).not.toContain('HIDDEN LIVE SUMMARY');
+  });
+  it('does not create a historical turn for Claude compact summaries', async () => {
+    const adapter = new ClaudeRuntimeAdapter({
+      home: '/tmp/claude-home',
+      query: (() => new FakeQuery([])) as any,
+      getSessionInfo: (async () => ({
+        sessionId: 'claude-session-1',
+        summary: 'Existing session',
+        lastModified: 1_772_000_000_000,
+        createdAt: 1_771_000_000_000,
+        cwd: '/tmp/workspace',
+        firstPrompt: 'Check training',
+      })) as any,
+      getSessionMessages: (async () => [
+        {
+          type: 'user',
+          uuid: uuidV7At(1_771_000_000_000),
+          session_id: 'claude-session-1',
+          message: { role: 'user', content: 'Check training' },
+          parent_tool_use_id: null,
+        },
+        {
+          type: 'assistant',
+          uuid: 'assistant-before-compact',
+          session_id: 'claude-session-1',
+          message: { role: 'assistant', content: [{ type: 'text', text: 'Before.' }] },
+          parent_tool_use_id: null,
+        },
+        {
+          type: 'user',
+          uuid: 'compact-summary',
+          session_id: 'claude-session-1',
+          message: {
+            role: 'user',
+            content: 'This session is being continued from a previous conversation that ran out of context. HIDDEN HISTORICAL SUMMARY',
+          },
+          parent_tool_use_id: null,
+        },
+        {
+          type: 'assistant',
+          uuid: 'assistant-after-compact',
+          session_id: 'claude-session-1',
+          message: { role: 'assistant', content: [{ type: 'text', text: 'After.' }] },
+          parent_tool_use_id: null,
+        },
+      ] satisfies SessionMessage[]) as any,
+    });
+    const session = await adapter.readSession('claude-session-1');
+    expect(session.turns).toHaveLength(1);
+    expect(session.turns[0]?.items).toEqual(expect.arrayContaining([
+      expect.objectContaining({ kind: 'userMessage', text: 'Check training' }),
+      expect.objectContaining({ kind: 'agentMessage', text: 'Before.' }),
+      expect.objectContaining({
+        kind: 'contextCompaction',
+        text: 'Context compacted',
+        detailText: null,
+      }),
+      expect.objectContaining({ kind: 'agentMessage', text: 'After.' }),
+    ]));
+    expect(JSON.stringify(session.turns)).not.toContain('HIDDEN HISTORICAL SUMMARY');
+  });
 });

package/packages/claude/src/runtimeAdapter.ts CHANGED Viewed

@@ -46,6 +46,7 @@ import {
   isHiddenContinuationMessage,
   isHiddenInitMessage,
   limitErrorFromHistoryItems,
+  messageContentText,
   partialReasoningDelta,
   partialTextDelta,
   resultForToolUse,
@@ -133,6 +134,16 @@ interface SDKMessage {
   errors?: string[];
   stop_reason?: string;
   rate_limit_info?: SDKRateLimitInfo;
+  compact_metadata?: {
+    trigger?: 'manual' | 'auto';
+    pre_tokens?: number;
+    post_tokens?: number;
+  };
+  compact_result?: 'success' | 'failed';
+  compact_error?: string;
+  status?: 'compacting' | 'requesting' | null;
+  isCompactSummary?: boolean;
+  is_compact_summary?: boolean;
 }
 interface SDKRateLimitInfo {
   status: 'allowed' | 'allowed_warning' | 'rejected';
@@ -244,11 +255,63 @@ interface ActiveClaudeTurn {
   assistantUsage: ClaudeTokenUsageBreakdown | null;
   resultUsage: ClaudeTokenUsageBreakdown | null;
   modelContextWindow: number | null;
+  currentCompactionItemId: string | null;
 }
 const promptPhotoTokenPattern = /\[PHOTO\s+([^\]]+)\]/g;
+const claudeCompactSummaryPrefix =
+  'This session is being continued from a previous conversation that ran out of context.';
 const activeTranscriptMatchWindowMs = 120_000;
+function isClaudeCompactBoundaryMessage(message: SDKMessage | SessionMessage) {
+  if (message.type !== 'system') {
+    return false;
+  }
+  if (message.subtype === 'compact_boundary' || message.compact_metadata) {
+    return true;
+  }
+  return isRecord(message.message)
+    && (message.message.subtype === 'compact_boundary' || isRecord(message.message.compact_metadata));
+}
+function isClaudeCompactSummaryMessage(message: SDKMessage | SessionMessage) {
+  if (message.type !== 'user' || message.parent_tool_use_id) {
+    return false;
+  }
+  const payload = isRecord(message.message) ? message.message : null;
+  if (
+    message.isCompactSummary
+    || message.is_compact_summary
+    || payload?.isCompactSummary === true
+    || payload?.is_compact_summary === true
+  ) {
+    return true;
+  }
+  return messageContentText(message.message).trim().startsWith(claudeCompactSummaryPrefix);
+}
+function claudeContextCompactionItem(
+  id: string,
+  status: 'running' | 'completed' | 'failed',
+  error: string | null = null,
+): AgentHistoryItem {
+  const completed = status === 'completed';
+  const failed = status === 'failed';
+  const text = failed
+    ? 'Context compaction failed'
+    : completed
+      ? 'Context compacted'
+      : 'Compacting context';
+  return {
+    id,
+    kind: 'contextCompaction',
+    text,
+    previewText: text,
+    detailText: failed ? error : null,
+    status,
+  };
+}
 function normalizePromptForTurnReconciliation(value: string) {
   return value
     // Claude history can rewrite or omit an image marker. The surrounding
@@ -1690,6 +1753,7 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
       assistantUsage: null,
       resultUsage: null,
       modelContextWindow: null,
+      currentCompactionItemId: null,
     };
     this.knownSessionIds.add(input.providerSessionId);
     let sessionPrompts = this.liveUserPrompts.get(input.providerSessionId);
@@ -1976,6 +2040,62 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
       return;
     }
+    if (message.type === 'system' && message.subtype === 'status') {
+      if (message.status === 'compacting') {
+        const existing = state.currentCompactionItemId
+          ? state.items.get(state.currentCompactionItemId)
+          : null;
+        const itemId = existing?.status === 'running'
+          ? existing.id
+          : `claude-compaction-${messageUuid(message, randomUUID())}`;
+        state.currentCompactionItemId = itemId;
+        const item = withHistoryItemCreatedAt(
+          claudeContextCompactionItem(itemId, 'running'),
+          messageCreatedAt,
+        );
+        addOrUpdateItem(state, item);
+        this.emitItem(state, item, 'item.started', { force: Boolean(existing) });
+        return;
+      }
+      if (message.compact_result) {
+        const itemId = state.currentCompactionItemId
+          ?? `claude-compaction-${messageUuid(message, randomUUID())}`;
+        const status = message.compact_result === 'success' ? 'completed' : 'failed';
+        const item = withHistoryItemCreatedAt(
+          claudeContextCompactionItem(itemId, status, message.compact_error ?? null),
+          messageCreatedAt,
+        );
+        addOrUpdateItem(state, item);
+        this.emitItem(state, item, 'item.completed');
+        state.currentCompactionItemId = status === 'failed' ? null : itemId;
+        return;
+      }
+      return;
+    }
+    if (isClaudeCompactBoundaryMessage(message)) {
+      const itemId = state.currentCompactionItemId
+        ?? `claude-compaction-${messageUuid(message, randomUUID())}`;
+      const previous = state.items.get(itemId);
+      const item = withHistoryItemCreatedAt(
+        claudeContextCompactionItem(itemId, 'completed'),
+        previous?.createdAt ?? messageCreatedAt,
+      );
+      addOrUpdateItem(state, item);
+      if (!previous) {
+        this.emitItem(state, item, 'item.started');
+      }
+      if (previous?.status !== 'completed') {
+        this.emitItem(state, item, 'item.completed');
+      }
+      state.currentCompactionItemId = null;
+      return;
+    }
+    if (isClaudeCompactSummaryMessage(message)) {
+      return;
+    }
     if (message.type === 'stream_event') {
       const nextStreamMessageId = streamMessageId(message.event);
       if (nextStreamMessageId) {
@@ -2408,6 +2528,8 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
       itemsById: Map<string, AgentHistoryItem>;
     } | null = null;
     let skippingHiddenInit = false;
+    let pendingCompactSummaryItemId: string | null = null;
+    let pendingCompactBoundaryItemId: string | null = null;
     const suppressedToolUseIds = new Set<string>();
     const upsertCurrentItem = (item: AgentHistoryItem) => {
@@ -2441,6 +2563,20 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
     };
     for (const message of messages) {
+      if (isClaudeCompactBoundaryMessage(message)) {
+        const itemId: string = pendingCompactSummaryItemId
+          ?? `claude-compaction-${messageUuid(message, randomUUID())}`;
+        pendingCompactSummaryItemId = null;
+        pendingCompactBoundaryItemId = itemId;
+        upsertCurrentItem(
+          withHistoryItemCreatedAt(
+            claudeContextCompactionItem(itemId, 'completed'),
+            sessionMessageTimestamp(message) ?? current?.startedAt,
+          ),
+        );
+        continue;
+      }
       if (message.type === 'user') {
         const taskNotification = taskNotificationToolResult(message.message);
         if (taskNotification) {
@@ -2487,6 +2623,21 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
       }
       if (message.type === 'user' && !message.parent_tool_use_id) {
+        if (isClaudeCompactSummaryMessage(message)) {
+          const itemId: string = pendingCompactBoundaryItemId
+            ?? `claude-compaction-${messageUuid(message, randomUUID())}`;
+          if (!pendingCompactBoundaryItemId) {
+            pendingCompactSummaryItemId = itemId;
+          }
+          pendingCompactBoundaryItemId = null;
+          upsertCurrentItem(
+            withHistoryItemCreatedAt(
+              claudeContextCompactionItem(itemId, 'completed'),
+              sessionMessageTimestamp(message) ?? current?.startedAt,
+            ),
+          );
+          continue;
+        }
         if (isHiddenInitMessage(message.message)) {
           skippingHiddenInit = true;
           current = null;
@@ -2506,19 +2657,19 @@ export class ClaudeRuntimeAdapter extends EventEmitter implements AgentRuntime {
             items: current.items,
           }));
         }
-        const messageUuid = message.uuid ?? randomUUID();
-        const userStartedAt = isoFromUuidV7(messageUuid);
+        const userMessageUuid = message.uuid ?? randomUUID();
+        const userStartedAt = isoFromUuidV7(userMessageUuid);
         const userItem = await this.userMessageToHistoryItem(
-          messageUuid,
+          userMessageUuid,
           message.message,
           context,
         );
         const stampedUserItem = withHistoryItemCreatedAt(userItem, userStartedAt);
         current = {
-          providerTurnId: `claude-turn-${messageUuid}`,
+          providerTurnId: `claude-turn-${userMessageUuid}`,
           startedAt: userStartedAt,
           items: [stampedUserItem],
-          itemsById: new Map([[messageUuid, stampedUserItem]]),
+          itemsById: new Map([[userMessageUuid, stampedUserItem]]),
         };
         continue;
       }

package/packages/shared/src/index.ts CHANGED Viewed

@@ -1156,7 +1156,7 @@ export interface ThreadAnsweredRequestNoteDto {
 export interface ThreadActivityNoteDto {
   id: string;
-  kind: 'fastMode' | 'forkCreated' | 'forkSource';
+  kind: 'fastMode' | 'goal' | 'forkCreated' | 'forkSource';
   createdAt: string;
   text?: string;
   anchorTurnId?: string | null;
@@ -1374,6 +1374,96 @@ export interface ThreadDetailDto {
   liveItems?: ThreadLiveItemsDto | null;
 }
+export function prependEarlierThreadTurns(
+  existing: ThreadDetailDto['turns'],
+  earlier: ThreadDetailDto['turns'],
+) {
+  const existingIds = new Set(existing.map((turn) => turn.id));
+  return [...earlier.filter((turn) => !existingIds.has(turn.id)), ...existing];
+}
+export function mergeLatestThreadTurns(
+  existing: ThreadDetailDto['turns'],
+  latest: ThreadDetailDto['turns'],
+  activeTurnId: string | null = null,
+) {
+  const seenLatestIds = new Set<string>();
+  const uniqueLatest = latest.reduceRight<ThreadDetailDto['turns']>(
+    (turns, turn) => {
+      if (!seenLatestIds.has(turn.id)) {
+        seenLatestIds.add(turn.id);
+        turns.unshift(turn);
+      }
+      return turns;
+    },
+    [],
+  );
+  const latestById = new Map(uniqueLatest.map((turn) => [turn.id, turn]));
+  const latestReplacements = uniqueLatest.filter((turn) =>
+    turn.items.some((item) => item.kind === 'userMessage'),
+  );
+  const replacedExistingIds = new Set<string>();
+  const seenExistingIds = new Set<string>();
+  const uniqueExisting = existing.reduceRight<ThreadDetailDto['turns']>(
+    (turns, turn) => {
+      if (!seenExistingIds.has(turn.id)) {
+        seenExistingIds.add(turn.id);
+        turns.unshift(turn);
+      }
+      return turns;
+    },
+    [],
+  );
+  for (const turn of uniqueExisting) {
+    if (latestById.has(turn.id)) {
+      replacedExistingIds.add(turn.id);
+      continue;
+    }
+    if (turn.status !== 'inProgress') {
+      continue;
+    }
+    const existingPrompt = turn.items.find(
+      (item) => item.kind === 'userMessage',
+    )?.text.trim();
+    const existingStartedAt = turn.startedAt
+      ? Date.parse(turn.startedAt)
+      : Number.NaN;
+    if (!existingPrompt || !Number.isFinite(existingStartedAt)) {
+      continue;
+    }
+    const materializedReplacement = latestReplacements.find((replacement) => {
+      const replacementPrompt = replacement.items.find(
+        (item) => item.kind === 'userMessage',
+      )?.text.trim();
+      const replacementStartedAt = replacement.startedAt
+        ? Date.parse(replacement.startedAt)
+        : Number.NaN;
+      return (
+        replacementPrompt === existingPrompt &&
+        Number.isFinite(replacementStartedAt) &&
+        Math.abs(replacementStartedAt - existingStartedAt) <= 15_000
+      );
+    });
+    if (materializedReplacement) {
+      replacedExistingIds.add(turn.id);
+    }
+  }
+  const olderTurns = uniqueExisting.filter(
+    (turn) => !latestById.has(turn.id) && !replacedExistingIds.has(turn.id),
+  );
+  const ordered = [...olderTurns, ...uniqueLatest];
+  if (!activeTurnId) {
+    return ordered;
+  }
+  const activeTurn = ordered.find((turn) => turn.id === activeTurnId);
+  return activeTurn
+    ? [...ordered.filter((turn) => turn.id !== activeTurnId), activeTurn]
+    : ordered;
+}
 export interface ThreadExportTurnOptionDto {
   turnId: string;
   turnNumber: number;