@cloudcli-ai/cloudcli 1.37.1 → 1.37.3

package/server/shared/tests/message-unification.test.ts

@@ -0,0 +1,218 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { prepareTranscriptMessages } from '@/shared/message-unification.js';
+import type { NormalizedMessage } from '@/shared/types.js';
+
+let nextId = 0;
+
+const message = (fields: Partial<NormalizedMessage>): NormalizedMessage => ({
+  id: `m-${(nextId += 1)}`,
+  sessionId: 'session',
+  timestamp: '2026-08-22T00:00:00.000Z',
+  provider: 'claude',
+  kind: 'text',
+  ...fields,
+} as NormalizedMessage);
+
+const prose = () => message({ kind: 'text', role: 'assistant', content: 'Working on it.' });
+
+const taskCall = (
+  toolName: string,
+  toolId: string,
+  toolInput: Record<string, unknown>,
+  toolUseResult: unknown,
+) => message({ kind: 'tool_use', toolName, toolId, toolInput, toolResult: { content: 'ok', toolUseResult } });
+
+const todosOf = (entry: NormalizedMessage) =>
+  (entry.toolInput as { todos: Array<{ content: string; status: string }> }).todos
+    .map((todo) => `${todo.status}:${todo.content}`);
+
+test('Claude task-tracker calls become one evolving checklist', () => {
+  const unified = prepareTranscriptMessages([
+    taskCall('TaskCreate', 't1', { subject: 'Read notes', activeForm: 'Reading notes' }, { task: { id: '1' } }),
+    taskCall('TaskCreate', 't2', { subject: 'Run tests', activeForm: 'Running tests' }, { task: { id: '2' } }),
+    prose(),
+    taskCall('TaskUpdate', 't3', { taskId: '1', status: 'completed' }, { success: true }),
+  ]);
+
+  const snapshots = unified.filter((entry) => entry.toolName === 'TodoWrite');
+  assert.equal(snapshots.length, 2, 'the two adjacent creates collapse into one snapshot');
+  assert.deepEqual(todosOf(snapshots[0]), ['pending:Read notes', 'pending:Run tests']);
+  assert.deepEqual(todosOf(snapshots[1]), ['completed:Read notes', 'pending:Run tests']);
+  assert.equal(
+    (snapshots[0].toolInput as { todos: Array<{ activeForm?: string }> }).todos[0].activeForm,
+    'Reading notes',
+  );
+});
+
+test('a task listing keeps the wording each task was created with', () => {
+  const unified = prepareTranscriptMessages([
+    taskCall('TaskCreate', 't1', { subject: 'Read notes', activeForm: 'Reading notes' }, { task: { id: '1' } }),
+    prose(),
+    taskCall('TaskList', 't2', {}, { tasks: [{ id: '1', subject: 'Read notes', status: 'in_progress' }] }),
+  ]);
+
+  const listed = unified.filter((entry) => entry.toolName === 'TodoWrite').at(-1);
+  assert.deepEqual(todosOf(listed!), ['in_progress:Read notes']);
+  assert.equal(
+    (listed!.toolInput as { todos: Array<{ activeForm?: string }> }).todos[0].activeForm,
+    'Reading notes',
+  );
+});
+
+test('a checklist that has not changed since it was last drawn is dropped', () => {
+  const unified = prepareTranscriptMessages([
+    message({ kind: 'tool_use', toolName: 'TodoWrite', toolId: 'w1', toolInput: { todos: [{ content: 'Ship it', status: 'pending' }] } }),
+    prose(),
+    message({ kind: 'tool_use', toolName: 'TodoWrite', toolId: 'w2', toolInput: { todos: [{ content: 'Ship it', status: 'pending' }] } }),
+  ]);
+
+  assert.deepEqual(unified.map((entry) => entry.toolId), ['w1', undefined]);
+});
+
+test('a superseded checklist and its result row both go', () => {
+  const unified = prepareTranscriptMessages([
+    message({ kind: 'tool_use', toolName: 'TodoWrite', toolId: 'w1', toolInput: { todos: [{ content: 'One', status: 'pending' }] } }),
+    message({ kind: 'tool_result', toolId: 'w1', content: 'stale' }),
+    message({ kind: 'tool_use', toolName: 'TodoWrite', toolId: 'w2', toolInput: { todos: [{ content: 'One', status: 'completed' }] } }),
+    message({ kind: 'tool_result', toolId: 'w2', content: 'fresh' }),
+  ]);
+
+  assert.deepEqual(unified.map((entry) => entry.toolId), ['w2']);
+});
+
+test('a result that names its call is not shipped alongside it', () => {
+  const unified = prepareTranscriptMessages([
+    message({ kind: 'tool_use', toolName: 'Bash', toolId: 'b1', toolInput: { command: 'ls' }, toolResult: { content: 'a\nb' } }),
+    message({ kind: 'tool_result', toolId: 'b1', content: 'a\nb' }),
+  ]);
+
+  assert.equal(unified.length, 1, 'the result already rides on the call it belongs to');
+  assert.equal(unified[0].kind, 'tool_use');
+  assert.equal(unified[0].toolResult?.content, 'a\nb');
+});
+
+test('a result with no call to attach to is kept', () => {
+  const unified = prepareTranscriptMessages([
+    message({ kind: 'tool_result', content: 'orphaned output' }),
+  ]);
+
+  assert.deepEqual(unified.map((entry) => entry.kind), ['tool_result']);
+});
+
+test("Codex's request_user_input becomes an answered AskUserQuestion", () => {
+  const [unified] = prepareTranscriptMessages([
+    message({
+      provider: 'codex',
+      kind: 'tool_use',
+      toolName: 'request_user_input',
+      toolId: 'call-1',
+      toolInput: JSON.stringify({
+        questions: [{ id: 'season', header: 'Quick test', question: 'Which season?', options: [{ label: 'Summer' }] }],
+      }),
+      toolResult: { content: '{"answers":{"season":{"answers":["Summer"]}}}' },
+    }),
+  ]);
+
+  assert.equal(unified.toolName, 'AskUserQuestion');
+  assert.deepEqual((unified.toolInput as { answers: unknown }).answers, { 'Which season?': 'Summer' });
+});
+
+test('a multi-select Codex answer keeps every label it picked', () => {
+  const [unified] = prepareTranscriptMessages([
+    message({
+      provider: 'codex',
+      kind: 'tool_use',
+      toolName: 'request_user_input',
+      toolId: 'call-1',
+      toolInput: JSON.stringify({ questions: [{ id: 'scope', question: 'Which areas?', options: [] }] }),
+      toolResult: { content: '{"answers":{"scope":{"answers":["Providers","Tests"]}}}' },
+    }),
+  ]);
+
+  assert.deepEqual((unified.toolInput as { answers: unknown }).answers, { 'Which areas?': 'Providers, Tests' });
+});
+
+test("Claude's AskUserQuestion answer is folded into the question it answers", () => {
+  const [unified] = prepareTranscriptMessages([
+    message({
+      kind: 'tool_use',
+      toolName: 'AskUserQuestion',
+      toolId: 'call-1',
+      toolInput: { questions: [{ question: 'What next?', header: 'Focus', options: [{ label: 'Branch changes' }] }] },
+      toolResult: {
+        content: 'Your questions have been answered.',
+        toolUseResult: { answers: { 'What next?': 'Branch changes' } },
+      },
+    }),
+  ]);
+
+  assert.deepEqual((unified.toolInput as { answers: unknown }).answers, { 'What next?': 'Branch changes' });
+});
+
+test('a live Claude answer is recovered from the acknowledgement sentence', () => {
+  const [unified] = prepareTranscriptMessages([
+    message({
+      kind: 'tool_use',
+      toolName: 'AskUserQuestion',
+      toolId: 'call-1',
+      toolInput: { questions: [{ question: 'What next?', options: [] }] },
+      toolResult: {
+        content: 'Your questions have been answered: "What next?"="Branch changes". You can now continue.',
+      },
+    }),
+  ]);
+
+  assert.deepEqual((unified.toolInput as { answers: unknown }).answers, { 'What next?': 'Branch changes' });
+});
+
+test('a question that was never answered carries no answers', () => {
+  const [unified] = prepareTranscriptMessages([
+    message({
+      kind: 'tool_use',
+      toolName: 'AskUserQuestion',
+      toolId: 'call-1',
+      toolInput: { questions: [{ question: 'What next?', options: [] }] },
+      toolResult: { content: '<tool_use_error>InputValidationError</tool_use_error>', isError: true },
+    }),
+  ]);
+
+  assert.equal((unified.toolInput as { answers?: unknown }).answers, undefined);
+});
+
+test('a huge tool output is capped, and says how much it dropped', () => {
+  const body = 'x'.repeat(120_000);
+  const [unified] = prepareTranscriptMessages([
+    message({
+      kind: 'tool_use',
+      toolName: 'Read',
+      toolId: 'r1',
+      toolInput: { file_path: '/tmp/shot.png' },
+      toolResult: { content: body, toolUseResult: { file: { base64: body } } },
+    }),
+  ]);
+
+  const content = String(unified.toolResult?.content);
+  assert.ok(content.length < body.length / 2, 'the output must not survive at full size');
+  assert.match(content, /… 80000 more characters$/);
+  const nested = (unified.toolResult?.toolUseResult as { file: { base64: string } }).file.base64;
+  assert.equal(nested, content, 'the structured copy is capped the same way');
+});
+
+test('a search result keeps every file it found', () => {
+  const filenames = Array.from({ length: 900 }, (_, index) => `/repo/src/file-${index}.ts`);
+  const [unified] = prepareTranscriptMessages([
+    message({
+      kind: 'tool_use',
+      toolName: 'Glob',
+      toolId: 'g1',
+      toolInput: { pattern: '**/*.ts' },
+      toolResult: { content: 'ok', toolUseResult: { numFiles: filenames.length, filenames } },
+    }),
+  ]);
+
+  const result = unified.toolResult?.toolUseResult as { filenames: string[]; numFiles: number };
+  assert.equal(result.numFiles, 900);
+  assert.deepEqual(result.filenames, filenames);
+});

package/server/shared/types.ts

@@ -186,9 +186,10 @@ export type MessageKind =
   | 'complete'
   | 'status'
   | 'permission_request'
+  | 'permission_resolved'
   | 'permission_cancelled'
   | 'session_created'
-  | 'interactive_prompt'
+  | 'history_truncated'
   | 'task_notification';
 
 /**
@@ -215,6 +216,42 @@ export type GatewayEventKind =
  */
 export type ServerEventKind = MessageKind | GatewayEventKind;
 
+/** The owning project as it appears inside a `session_upserted` delta. */
+export type SessionUpsertedProject = {
+  projectId: string;
+  path: string;
+  fullPath: string;
+  displayName: string;
+  isStarred: boolean;
+};
+
+/**
+ * The `session_upserted` sidebar delta, built only by
+ * `modules/websocket/services/session-upsert-broadcast.service.ts`.
+ *
+ * Typed rather than assembled as an untyped object literal because the payload
+ * used to be built in two places and silently drifted apart: one copy set
+ * `providerSessionId` and the other did not, and nothing could detect it.
+ *
+ * `providerSessionId` is how a client recognises that a row it is currently
+ * showing has been merged into its canonical app-session row, so it is always
+ * present — `null` only while the provider has not reported an id yet.
+ */
+export type SessionUpsertedEvent = {
+  kind: 'session_upserted';
+  sessionId: string;
+  providerSessionId: string | null;
+  provider: LLMProvider;
+  session: {
+    id: string;
+    summary: string;
+    messageCount: number;
+    lastActivity: string;
+  };
+  project: SessionUpsertedProject | null;
+  timestamp: string;
+};
+
 /**
  * Provider-neutral message envelope used in REST responses and realtime channels.
  *
@@ -223,6 +260,13 @@ export type ServerEventKind = MessageKind | GatewayEventKind;
  */
 export type NormalizedMessage = {
   id: string;
+  /**
+   * The provider's own identifier for the transcript row this message came
+   * from, when the provider has stable per-row identity (today: Claude's
+   * `uuid`). It is what "edit this message" and "fork from here" address, so it
+   * has to survive a reload — never a value this app synthesized.
+   */
+  transcriptAnchorId?: string;
   sessionId: string;
   timestamp: string;
   provider: LLMProvider;
@@ -274,13 +318,90 @@ export type NormalizedMessage = {
   status?: string;
   summary?: string;
   tokenBudget?: unknown;
-  subagentTools?: unknown;
+  /**
+   * Timeline of everything a subagent did, attached to the `tool_use` that
+   * spawned it. Present for Claude `Agent`/`Task` calls and Codex
+   * `spawn_agent` calls; absent for every other tool.
+   */
+  subagentTools?: SubagentActivity[];
+  /** Identity and lifecycle of the subagent this `tool_use` spawned. */
+  subagent?: SubagentInfo;
+  /** Stored memory the reply drew on, when the provider reports it. */
+  memoryCitations?: MemoryCitation[];
   toolUseResult?: unknown;
   sequence?: number;
   rowid?: number;
   [key: string]: unknown;
 };
 
+/**
+ * One stored memory an assistant reply drew on.
+ *
+ * Codex appends these to a reply that used its memory files, naming the file
+ * and line range it read plus a short note on what it took from there. The
+ * transcript shows them as a footnote so a memory-derived claim is traceable
+ * rather than arriving as an unattributed assertion.
+ */
+export type MemoryCitation = {
+  /** File and line range that was read, e.g. `MEMORY.md:137-142`. */
+  source: string;
+  /** What the reply took from that range, when the provider states it. */
+  note?: string;
+};
+
+/**
+ * One entry in a subagent's recorded timeline.
+ *
+ * Providers store a subagent's work in a separate transcript (Claude:
+ * `<session>/subagents/agent-<id>.jsonl`; Codex: a sibling rollout keyed by
+ * `agent_thread_id`). Both are flattened into this shape so the transcript can
+ * replay a subagent's run with the same renderers the main thread uses.
+ *
+ * `kind` decides which fields matter: `tool` uses the tool fields, `text` and
+ * `thinking` use `content`. Consumers must not assume tool fields exist on the
+ * text kinds.
+ */
+export type SubagentActivity = {
+  kind: 'tool' | 'text' | 'thinking';
+  timestamp?: string;
+  /** Tool-call identity; only set when `kind` is `tool`. */
+  toolId?: string;
+  toolName?: string;
+  toolInput?: unknown;
+  toolResult?: { content?: string; isError?: boolean } | null;
+  /** Message body; only set when `kind` is `text` or `thinking`. */
+  content?: string;
+};
+
+/**
+ * Identity and lifecycle of one spawned subagent, normalized across providers.
+ *
+ * `status` is `running` until the call that spawned the agent resolves. After
+ * that it is whatever the provider reported — Claude's task notification
+ * carries one — and `completed` when the provider reported nothing. A failed
+ * tool call *inside* the agent is not a failed agent, so it is never inferred
+ * from the transcript.
+ */
+export type SubagentInfo = {
+  /** Provider-native agent id — Claude `agentId`, Codex `agent_thread_id`. */
+  id: string;
+  /** Human-facing label: Claude's agent type, or Codex's assigned nickname. */
+  name?: string;
+  /** Agent type/preset when the provider records one (Claude `agentType`). */
+  type?: string;
+  /** One-line task summary shown in the collapsed header. */
+  description?: string;
+  status: 'running' | 'completed' | 'failed';
+  /** Model the subagent ran on, when the provider records it. */
+  model?: string;
+  /**
+   * How many activities the agent actually recorded. It exceeds
+   * `subagentTools.length` when a long run was truncated for transport, which
+   * lets the UI say so instead of silently showing a partial timeline.
+   */
+  activityCount?: number;
+};
+
 /**
  * Output gateway shared by WebSocket and SSE provider runs.
  *
@@ -1182,7 +1303,6 @@ export type CliOutput = {
  * path-keyed fakes, so service tests never inspect or modify the real machine.
  */
 export type CliFileSystem = {
-  readTextFile(filePath: string): string;
   pathExists(filePath: string): boolean;
   getFileStats(filePath: string): { size: number; modifiedAt: Date };
 };

package/server/shared/utils.ts

@@ -27,9 +27,20 @@ import type {
   ProviderCurrentActiveModel,
   ProviderModelsDefinition,
   ProviderSkillSource,
+  SubagentActivity,
   WorkspacePathValidationResult,
 } from '@/shared/types.js';
 
+//----------------- ENVIRONMENT UTILITIES ------------
+/**
+ * Indicates whether the backend is running in hosted Platform mode rather than
+ * self-hosted OSS mode. The server bootstrap, Agent, Auth, and Browser Use
+ * modules use this shared flag to keep environment-dependent behavior aligned.
+ * Environment variables must be loaded before this module is evaluated.
+ */
+export const IS_PLATFORM = process.env.VITE_IS_PLATFORM === 'true';
+
+// ---------------------------
 //----------------- NORMALIZED MESSAGE HELPER INPUT TYPES ------------
 /**
  * Input payload accepted by `createNormalizedMessage`.
@@ -381,6 +392,45 @@ export function createCompleteMessage(opts: {
   });
 }
 
+// ---------------------------
+//----------------- SUBAGENT TIMELINE UTILITIES ------------
+/**
+ * Longest tool output kept on one subagent activity.
+ *
+ * A subagent's timeline is nested inside a collapsed panel, so it is a preview
+ * of what the agent did, never the primary place its output is read. Sending
+ * every child command's full output made the history payload of an
+ * agent-heavy session grow by megabytes for content almost nobody expands.
+ */
+const MAX_SUBAGENT_ACTIVITY_CONTENT = 4000;
+
+function truncateForPreview(value: string | undefined): string | undefined {
+  if (typeof value !== 'string' || value.length <= MAX_SUBAGENT_ACTIVITY_CONTENT) {
+    return value;
+  }
+  const omitted = value.length - MAX_SUBAGENT_ACTIVITY_CONTENT;
+  return `${value.slice(0, MAX_SUBAGENT_ACTIVITY_CONTENT)}\n… ${omitted} more characters`;
+}
+
+/**
+ * Trims one subagent activity down to what its nested preview can show.
+ *
+ * Used by both provider session adapters so a Claude agent's timeline and a
+ * Codex agent's timeline cost the same to transport.
+ */
+export function truncateSubagentActivity(activity: SubagentActivity): SubagentActivity {
+  const truncatedContent = truncateForPreview(activity.content);
+  const truncatedResult = activity.toolResult
+    ? { ...activity.toolResult, content: truncateForPreview(activity.toolResult.content) }
+    : activity.toolResult;
+
+  if (truncatedContent === activity.content && truncatedResult === activity.toolResult) {
+    return activity;
+  }
+
+  return { ...activity, content: truncatedContent, toolResult: truncatedResult };
+}
+
 // ---------------------------
 //----------------- CONVERSATION HISTORY PAGINATION UTILITIES ------------
 /**

package/server/tsconfig.json

@@ -23,7 +23,11 @@
     // The backend build emits both /server and /shared into dist-server, so rootDir must
     // stay one level above this file even though the config itself now lives in /server.
     "rootDir": "..",
-    "outDir": "../dist-server",
+    // The build stages into dist-server.next; scripts/promote-dist-server.mjs
+    // (postbuild:server) swaps it into dist-server once tsc and tsc-alias have
+    // both finished. Never emit into the live dist-server: an interrupted build
+    // must not be able to destroy the build the server is running from.
+    "outDir": "../dist-server.next",
     "sourceMap": true,
     "resolveJsonModule": true,
     "esModuleInterop": true,
@@ -32,5 +36,5 @@
     "types": ["node"]
   },
   "include": ["./**/*.js", "./**/*.ts", "../shared/**/*.js", "../shared/**/*.ts"],
-  "exclude": ["../dist", "../dist-server", "../node_modules", "../src"]
+  "exclude": ["../dist", "../dist-server", "../dist-server.next", "../dist-server.old", "../node_modules", "../src"]
 }