replicas-engine 0.1.220 → 0.1.222

package/dist/src/index.js

@@ -32,6 +32,9 @@ function codexReasoningEffortForThinkingLevel(thinkingLevel) {
 }
 
 // ../shared/src/event.ts
+var ACCEPTED_USER_MESSAGE_SOURCE = "replicas-chat-turn-accepted";
+var USER_MESSAGE_ID_PAYLOAD_KEY = "replicasMessageId";
+var CODEX_ASP_ITEM_ID_PAYLOAD_KEY = "codexAspItemId";
 var CODEX_QUOTA_STATUS_EVENT_TYPE = "codex-quota-status";
 var COMPACTION_STATUS_EVENT_TYPE = "compaction-status";
 var CHAT_GOAL_EVENT_TYPE = "chat-goal";
@@ -707,8 +710,8 @@ gh pr review 123 --request-changes --body "Changes needed"
 GitHub does NOT have a public API for uploading images to PRs/issues. When you need to include images:
 - Do NOT use placeholder image URLs
 - Do NOT commit screenshots as files to the repository
-- Upload images to Imgur (or another external host) and use the returned URLs in your PR markdown
-- If you were triggered from Slack, also upload the images to the Slack thread so the user can see them directly
+- Use the \`replicas-agent\` skill to share the image
+- If you were triggered from Slack, also upload the image to the Slack thread so the user can see it directly
 `;
 var GITHUB_ABILITY = {
   label: "GitHub",
@@ -1156,10 +1159,9 @@ After (or alongside) the embeds, include a \`[View in Replicas](<deep-link>)\` h
 
 ### On external platforms (Slack, Linear, GitHub, etc.)
 
-Do **both** of these \u2014 neither alone is sufficient:
+Always include a \`[View in Replicas](<deep-link>)\` hyperlink \u2014 use the per-file deep link the CLI printed for that file (\`...?mode=media&media=<media-id>\`), so the recipient lands directly on that specific item.
 
-1. Upload the raw bytes via that platform's own upload API (Slack \`files.upload\`, Linear attachments, Imgur for GitHub PR/issue images, etc.) so the recipient actually sees the media.
-2. Include a \`[View in Replicas](<deep-link>)\` hyperlink \u2014 use the per-file deep link the CLI printed for that file (\`...?mode=media&media=<media-id>\`), so the recipient lands directly on that specific item.
+For platforms that support native uploads (Slack \`files.upload\`, Linear attachments, etc.), upload the raw bytes there too so the recipient sees the media inline in addition to the Replicas link. GitHub PRs/issues do not have a public upload API, so the \`View in Replicas\` link is the canonical way to share media there \u2014 do not commit screenshots to the repo and do not use placeholder URLs.
 
 Do **not** include the \`![filename](https://api.tryreplicas.com/...)\` markdown embed in external messages. It will render as a broken image / 401 for the recipient.
 
@@ -1205,7 +1207,7 @@ replicas media upload chart-a.svg chart-b.svg --kind image
 var MEDIA_ABILITY = {
   label: "Media",
   description: "Share screenshots, recordings, generated images, and audio clips.",
-  bullet: "- Sharing media (screenshots, screen recordings, generated diagrams, audio clips) \u2014 including in your Replicas chat reply and to external platforms",
+  bullet: "- Producing or showing the user any media \u2014 screenshots, screen recordings, generated images or diagrams, audio clips \u2014 including in your Replicas chat reply, PR descriptions/comments, and other external platforms",
   section: SECTION6,
   referenceFile: { name: "MEDIA.md", content: REFERENCE6 }
 };
@@ -1761,7 +1763,7 @@ function parseReplicasConfigString(content, filename) {
 }
 
 // ../shared/src/engine/environment.ts
-var DAYTONA_SNAPSHOT_ID = "27-05-2026-royal-york-v2";
+var DAYTONA_SNAPSHOT_ID = "27-05-2026-royal-york-v6";
 
 // ../shared/src/engine/types.ts
 var DEFAULT_CHAT_TITLES = {
@@ -1814,6 +1816,12 @@ function codexAuthEnvFromResponse(response) {
       return { OPENAI_API_KEY: response.apiKey, REPLICAS_CODEX_AUTH_METHOD: "api_key" };
   }
 }
+var CODEX_AUTH_ENV_KEYS_BY_METHOD = {
+  none: [],
+  oauth: ["REPLICAS_CODEX_AUTH_METHOD"],
+  api_key: ["OPENAI_API_KEY", "REPLICAS_CODEX_AUTH_METHOD"],
+  bedrock: []
+};
 
 // ../shared/src/routes/claude.ts
 var CLAUDE_AUTH_ENV_KEYS = [
@@ -1840,6 +1848,18 @@ function claudeAuthEnvFromResponse(response) {
       };
   }
 }
+var CLAUDE_AUTH_ENV_KEYS_BY_METHOD = {
+  none: [],
+  oauth: ["REPLICAS_CLAUDE_AUTH_METHOD"],
+  api_key: ["ANTHROPIC_API_KEY", "REPLICAS_CLAUDE_AUTH_METHOD"],
+  bedrock: [
+    "CLAUDE_CODE_USE_BEDROCK",
+    "AWS_ACCESS_KEY_ID",
+    "AWS_SECRET_ACCESS_KEY",
+    "AWS_REGION",
+    "REPLICAS_CLAUDE_AUTH_METHOD"
+  ]
+};
 
 // ../shared/src/routes/workspaces.ts
 var WORKSPACE_FILE_UPLOAD_MAX_SIZE_BYTES = 20 * 1024 * 1024;
@@ -1863,6 +1883,50 @@ var MEDIA_KIND = {
 };
 var MEDIA_KINDS = [MEDIA_KIND.IMAGE, MEDIA_KIND.VIDEO, MEDIA_KIND.AUDIO];
 
+// ../shared/src/agent-event-utils.ts
+function getUserMessage(event) {
+  return event.type === "event_msg" && event.payload.type === "user_message" && typeof event.payload.message === "string" ? event.payload.message : null;
+}
+function getUserMessageId(event) {
+  const messageId = event.payload[USER_MESSAGE_ID_PAYLOAD_KEY];
+  return typeof messageId === "string" ? messageId : null;
+}
+function getUserMessageItemId(event) {
+  const itemId = event.payload[CODEX_ASP_ITEM_ID_PAYLOAD_KEY];
+  return typeof itemId === "string" ? itemId : null;
+}
+function getEventTimestampMs(event) {
+  const value = Date.parse(event.timestamp);
+  return Number.isNaN(value) ? 0 : value;
+}
+function areSameUserMessageEvents(a, b) {
+  const aMessage = getUserMessage(a);
+  const bMessage = getUserMessage(b);
+  if (!aMessage || aMessage !== bMessage) return false;
+  const aMessageId = getUserMessageId(a);
+  const bMessageId = getUserMessageId(b);
+  if (aMessageId || bMessageId) return aMessageId === bMessageId;
+  const aItemId = getUserMessageItemId(a);
+  const bItemId = getUserMessageItemId(b);
+  if (aItemId || bItemId) return aItemId === bItemId;
+  return Math.abs(getEventTimestampMs(a) - getEventTimestampMs(b)) <= 3e4;
+}
+function mergeAgentEvents(primary, supplemental, options) {
+  const merged = [...primary];
+  const { areDuplicates, mergeEvent } = options;
+  for (const event of supplemental) {
+    const existingIndex = merged.findIndex((existing) => areDuplicates(existing, event));
+    if (existingIndex === -1) {
+      merged.push(event);
+      continue;
+    }
+    if (mergeEvent) {
+      merged[existingIndex] = mergeEvent(merged[existingIndex], event);
+    }
+  }
+  return merged;
+}
+
 // src/runtime-env-loader.ts
 function loadRuntimeEnvFile() {
   let content;
@@ -2108,6 +2172,26 @@ var githubTokenManager = new GitHubTokenManager();
 // src/managers/claude-token-manager.ts
 import { promises as fs2 } from "fs";
 import path2 from "path";
+
+// src/managers/auth-env-transition.ts
+function applyAuthEnvTransition(params) {
+  const newOwned = new Set(params.authKeysByMethod[params.newMethod]);
+  const prevOwned = new Set(params.authKeysByMethod[params.prevMethod]);
+  for (const key of params.authKeys) {
+    const value = params.newEnvVars[key];
+    if (value !== void 0) {
+      for (const env of params.envs) {
+        env[key] = value;
+      }
+    } else if (prevOwned.has(key) && !newOwned.has(key)) {
+      for (const env of params.envs) {
+        delete env[key];
+      }
+    }
+  }
+}
+
+// src/managers/claude-token-manager.ts
 var ClaudeTokenManager = class extends BaseRefreshManager {
   constructor() {
     super("ClaudeTokenManager");
@@ -2175,34 +2259,14 @@ var ClaudeTokenManager = class extends BaseRefreshManager {
       await this.removeOauthCredentialsFile();
     }
     const envVars = claudeAuthEnvFromResponse(response);
-    for (const key of CLAUDE_AUTH_ENV_KEYS) {
-      switch (key) {
-        case "REPLICAS_CLAUDE_AUTH_METHOD":
-          ENGINE_ENV.REPLICAS_CLAUDE_AUTH_METHOD = envVars.REPLICAS_CLAUDE_AUTH_METHOD;
-          break;
-        case "ANTHROPIC_API_KEY":
-          ENGINE_ENV.ANTHROPIC_API_KEY = envVars.ANTHROPIC_API_KEY;
-          break;
-        case "CLAUDE_CODE_USE_BEDROCK":
-          ENGINE_ENV.CLAUDE_CODE_USE_BEDROCK = envVars.CLAUDE_CODE_USE_BEDROCK;
-          break;
-        case "AWS_ACCESS_KEY_ID":
-          ENGINE_ENV.AWS_ACCESS_KEY_ID = envVars.AWS_ACCESS_KEY_ID;
-          break;
-        case "AWS_SECRET_ACCESS_KEY":
-          ENGINE_ENV.AWS_SECRET_ACCESS_KEY = envVars.AWS_SECRET_ACCESS_KEY;
-          break;
-        case "AWS_REGION":
-          ENGINE_ENV.AWS_REGION = envVars.AWS_REGION;
-          break;
-      }
-      const value = envVars[key];
-      if (value !== void 0) {
-        process.env[key] = value;
-      } else {
-        delete process.env[key];
-      }
-    }
+    applyAuthEnvTransition({
+      prevMethod: ENGINE_ENV.REPLICAS_CLAUDE_AUTH_METHOD ?? "none",
+      newMethod: envVars.REPLICAS_CLAUDE_AUTH_METHOD ?? "none",
+      authKeys: CLAUDE_AUTH_ENV_KEYS,
+      authKeysByMethod: CLAUDE_AUTH_ENV_KEYS_BY_METHOD,
+      newEnvVars: envVars,
+      envs: [ENGINE_ENV, process.env]
+    });
   }
   async writeOauthCredentialsFile(credentials) {
     const workspaceHome = ENGINE_ENV.HOME_DIR;
@@ -2301,22 +2365,14 @@ var CodexTokenManager = class extends BaseRefreshManager {
       await this.removeOauthCredentialsFile();
     }
     const envVars = codexAuthEnvFromResponse(response);
-    for (const key of CODEX_AUTH_ENV_KEYS) {
-      switch (key) {
-        case "REPLICAS_CODEX_AUTH_METHOD":
-          ENGINE_ENV.REPLICAS_CODEX_AUTH_METHOD = envVars.REPLICAS_CODEX_AUTH_METHOD;
-          break;
-        case "OPENAI_API_KEY":
-          ENGINE_ENV.OPENAI_API_KEY = envVars.OPENAI_API_KEY;
-          break;
-      }
-      const value = envVars[key];
-      if (value !== void 0) {
-        process.env[key] = value;
-      } else {
-        delete process.env[key];
-      }
-    }
+    applyAuthEnvTransition({
+      prevMethod: ENGINE_ENV.REPLICAS_CODEX_AUTH_METHOD ?? "none",
+      newMethod: envVars.REPLICAS_CODEX_AUTH_METHOD ?? "none",
+      authKeys: CODEX_AUTH_ENV_KEYS,
+      authKeysByMethod: CODEX_AUTH_ENV_KEYS_BY_METHOD,
+      newEnvVars: envVars,
+      envs: [ENGINE_ENV, process.env]
+    });
   }
   async writeOauthCredentialsFile(credentials) {
     const workspaceHome = ENGINE_ENV.HOME_DIR;
@@ -6265,21 +6321,27 @@ function itemToAgentEventDrafts(item, lifecycle) {
 }
 function threadToHistoryEvents(thread) {
   const events = [];
-  for (const turn of thread.turns) {
+  const turns = thread.turns.map((turn, index) => ({ turn, index })).sort((a, b) => (a.turn.startedAt ?? a.turn.completedAt ?? Number.MAX_SAFE_INTEGER) - (b.turn.startedAt ?? b.turn.completedAt ?? Number.MAX_SAFE_INTEGER) || a.index - b.index);
+  for (const { turn } of turns) {
     const startedAt = timestampFromSeconds(turn.startedAt);
     const completedAt = timestampFromSeconds(turn.completedAt ?? turn.startedAt);
-    for (const item of turn.items) {
-      if (item.type === "userMessage") {
-        const message = item.content.filter((input) => input.type === "text").map((input) => input.text).join("\n");
-        if (message) {
-          events.push({
-            timestamp: startedAt,
-            type: "event_msg",
-            payload: { type: "user_message", message }
-          });
-        }
-        continue;
+    const userMessages = turn.items.filter((item) => item.type === "userMessage");
+    const agentItems = turn.items.filter((item) => item.type !== "userMessage");
+    for (const item of userMessages) {
+      const message = item.content.filter((input) => input.type === "text").map((input) => input.text).join("\n");
+      if (message) {
+        events.push({
+          timestamp: startedAt,
+          type: "event_msg",
+          payload: {
+            type: "user_message",
+            message,
+            [CODEX_ASP_ITEM_ID_PAYLOAD_KEY]: item.id
+          }
+        });
       }
+    }
+    for (const item of agentItems) {
       for (const draft of itemToAgentEventDrafts(item, "started")) {
         events.push({ timestamp: startedAt, ...draft });
       }
@@ -6380,6 +6442,49 @@ function dispatchAspNotification(notification, handlers) {
 }
 
 // src/managers/codex-asp/codex-asp-manager.ts
+function historyEventKey(event) {
+  const payloadType = typeof event.payload.type === "string" ? event.payload.type : null;
+  const callId = typeof event.payload.call_id === "string" ? event.payload.call_id : null;
+  const itemId = typeof event.payload[CODEX_ASP_ITEM_ID_PAYLOAD_KEY] === "string" ? event.payload[CODEX_ASP_ITEM_ID_PAYLOAD_KEY] : null;
+  const messageId = typeof event.payload[USER_MESSAGE_ID_PAYLOAD_KEY] === "string" ? event.payload[USER_MESSAGE_ID_PAYLOAD_KEY] : null;
+  if (event.type === "response_item" && payloadType && callId) {
+    return `${event.type}:${payloadType}:${callId}`;
+  }
+  if (event.type === "event_msg" && event.payload.type === "user_message") {
+    if (messageId) return `${event.type}:user_message:message:${messageId}`;
+    if (itemId) return `${event.type}:user_message:item:${itemId}`;
+    const command = typeof event.payload.command === "string" ? event.payload.command : "";
+    const message = typeof event.payload.message === "string" ? event.payload.message : "";
+    return `${event.type}:user_message:${event.timestamp}:${command}:${message}`;
+  }
+  if (itemId && payloadType) {
+    return `${event.type}:${payloadType}:item:${itemId}`;
+  }
+  return `${event.type}:${event.timestamp}:${JSON.stringify(event.payload)}`;
+}
+function areDuplicateHistoryEvents(a, b) {
+  if (historyEventKey(a) === historyEventKey(b)) return true;
+  return areSameUserMessageEvents(a, b);
+}
+function mergeHistoryEvent(current, candidate) {
+  if (getUserMessage(current) && getUserMessage(current) === getUserMessage(candidate)) {
+    return {
+      ...current,
+      timestamp: getEventTimestampMs(current) <= getEventTimestampMs(candidate) ? current.timestamp : candidate.timestamp,
+      payload: {
+        ...current.payload,
+        ...candidate.payload
+      }
+    };
+  }
+  return candidate;
+}
+function mergeHistoryEvents(primary, supplemental) {
+  return mergeAgentEvents(primary, supplemental, {
+    areDuplicates: areDuplicateHistoryEvents,
+    mergeEvent: mergeHistoryEvent
+  });
+}
 var CodexAspManager = class extends CodingAgentManager {
   currentThreadId = null;
   activeTurnId = null;
@@ -6425,15 +6530,13 @@ var CodexAspManager = class extends CodingAgentManager {
         ),
         this.refreshThreadGoal(host, this.currentThreadId)
       ]);
-      const events = threadToHistoryEvents(response.thread);
-      if (events.length > 0) {
-        const supplementalEvents = this.historyEvents.filter((event) => event.type === CODEX_QUOTA_STATUS_EVENT_TYPE || event.type === CONTEXT_USAGE_EVENT_TYPE || event.type === CHAT_GOAL_EVENT_TYPE || event.type === "event_msg" && event.payload.command === "goal");
-        return {
-          thread_id: this.currentThreadId,
-          events: [...events, ...supplementalEvents].sort((a, b) => a.timestamp.localeCompare(b.timestamp)),
-          goal: this.currentGoal
-        };
-      }
+      const events = mergeHistoryEvents(this.historyEvents, threadToHistoryEvents(response.thread));
+      this.historyEvents.splice(0, this.historyEvents.length, ...events);
+      return {
+        thread_id: this.currentThreadId,
+        events,
+        goal: this.currentGoal
+      };
     } catch {
     }
     return {
@@ -6492,8 +6595,8 @@ var CodexAspManager = class extends CodingAgentManager {
   async executeGoalClearCommand(request, recordUserMessage) {
     const host = await getCodexAspHost();
     const developerInstructions = this.buildCombinedInstructions(request.customInstructions);
-    const threadId = await this.ensureThread(host, request, developerInstructions);
     recordUserMessage({ command: "goal" });
+    const threadId = await this.ensureThread(host, request, developerInstructions);
     await host.client.request(
       THREAD_GOAL_CLEAR_METHOD,
       { threadId }
@@ -6511,8 +6614,8 @@ var CodexAspManager = class extends CodingAgentManager {
       }
     }
     const developerInstructions = this.buildCombinedInstructions(request.customInstructions);
-    const threadId = await this.ensureThread(host, request, developerInstructions);
     recordUserMessage(options.userMessagePayload);
+    const threadId = await this.ensureThread(host, request, developerInstructions);
     const runTurn = options.runTurn ?? ((aspHost, aspThreadId, aspInstructions) => this.runTurn(aspHost, aspThreadId, request, aspInstructions));
     let completedTurn;
     try {
@@ -6747,8 +6850,7 @@ var CodexAspManager = class extends CodingAgentManager {
   }
   seedHistoryFromThread(thread) {
     const events = threadToHistoryEvents(thread);
-    if (events.length === 0) return;
-    this.historyEvents.splice(0, this.historyEvents.length, ...events);
+    this.historyEvents.splice(0, this.historyEvents.length, ...mergeHistoryEvents(this.historyEvents, events));
   }
   async refreshThreadGoal(host, threadId) {
     try {
@@ -7457,6 +7559,19 @@ function isPersistedChat(value) {
   const candidate = value;
   return typeof candidate.id === "string" && (candidate.provider === "claude" || candidate.provider === "codex" || candidate.provider === "relay") && typeof candidate.title === "string" && typeof candidate.createdAt === "string" && typeof candidate.updatedAt === "string" && (candidate.providerSessionId === null || typeof candidate.providerSessionId === "string") && (candidate.parentChatId === void 0 || candidate.parentChatId === null || typeof candidate.parentChatId === "string");
 }
+function createUserMessageEvent(message, messageId) {
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    type: "event_msg",
+    payload: {
+      type: "user_message",
+      message,
+      source: ACCEPTED_USER_MESSAGE_SOURCE,
+      [USER_MESSAGE_ID_PAYLOAD_KEY]: messageId
+    }
+  };
+}
+var isSameUserMessageEvent = areSameUserMessageEvents;
 var ChatService = class {
   constructor(workingDirectory) {
     this.workingDirectory = workingDirectory;
@@ -7534,7 +7649,9 @@ var ChatService = class {
   async sendMessage(chatId, request) {
     const chat = this.requireChat(chatId);
     const result = await chat.provider.enqueueMessage(request);
+    const acceptedEvent = createUserMessageEvent(request.message, result.messageId);
     chat.pendingMessageIds.push(result.messageId);
+    chat.acceptedUserEvents.set(result.messageId, acceptedEvent);
     this.touch(chat);
     let recordedSender;
     if (request.senderUserId && request.senderEmail) {
@@ -7553,6 +7670,7 @@ var ChatService = class {
         messageId: result.messageId,
         queued: result.queued,
         position: result.position,
+        event: acceptedEvent,
         ...recordedSender ? { sender: recordedSender } : {}
       }
     });
@@ -7599,8 +7717,10 @@ var ChatService = class {
     const chat = this.requireChat(chatId);
     const result = await chat.provider.interrupt();
     chat.hasActiveTurn = false;
+    chat.activeMessageId = null;
     keepAliveService.stop();
     chat.pendingMessageIds = [];
+    chat.acceptedUserEvents.clear();
     this.touch(chat);
     await this.publish({
       type: "chat.interrupted",
@@ -7690,9 +7810,10 @@ var ChatService = class {
       chat.provider.getHistory(),
       this.readSenders(chatId)
     ]);
+    const acceptedEvents = [...chat.acceptedUserEvents.values()].filter((acceptedEvent) => !history.events.some((event) => isSameUserMessageEvent(event, acceptedEvent)));
     return {
       thread_id: history.thread_id,
-      events: history.events,
+      events: [...history.events, ...acceptedEvents],
       goal: history.goal ?? chat.provider.getGoal?.() ?? null,
       senders
     };
@@ -7760,6 +7881,8 @@ var ChatService = class {
       persisted,
       provider,
       pendingMessageIds: [],
+      acceptedUserEvents: /* @__PURE__ */ new Map(),
+      activeMessageId: null,
       hasActiveTurn: false,
       observedBranchesByRepo: /* @__PURE__ */ new Map()
     };
@@ -7801,6 +7924,7 @@ var ChatService = class {
         return;
       }
       chat.hasActiveTurn = true;
+      chat.activeMessageId = messageId;
       keepAliveService.start();
       this.publish({
         type: "chat.turn.started",
@@ -7811,6 +7935,25 @@ var ChatService = class {
       }).catch(() => {
       });
     }
+    let eventToPublish = event;
+    if (event.type === "event_msg" && event.payload.type === "user_message") {
+      if (chat.activeMessageId) {
+        event.payload[USER_MESSAGE_ID_PAYLOAD_KEY] = chat.activeMessageId;
+        eventToPublish = {
+          ...event,
+          payload: {
+            ...event.payload,
+            [USER_MESSAGE_ID_PAYLOAD_KEY]: chat.activeMessageId
+          }
+        };
+      }
+      for (const [messageId, acceptedEvent] of chat.acceptedUserEvents) {
+        if (isSameUserMessageEvent(event, acceptedEvent)) {
+          chat.acceptedUserEvents.delete(messageId);
+          break;
+        }
+      }
+    }
     this.touch(chat);
     this.observeCurrentBranches(chat).catch(() => {
     });
@@ -7818,7 +7961,7 @@ var ChatService = class {
       type: "chat.turn.delta",
       payload: {
         chatId,
-        event
+        event: eventToPublish
       }
     }).catch(() => {
     });
@@ -7840,6 +7983,7 @@ var ChatService = class {
       return;
     }
     chat.hasActiveTurn = false;
+    chat.activeMessageId = null;
     keepAliveService.stop();
     this.publish({
       type: "chat.turn.completed",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.220",
+  "version": "0.1.222",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",