Skip to content
TypeScript

fix(mobile): drafts on threads with colons in their ids upload attachments early (#29717)

Julius Marminge927a2c60505a
diff --git a/apps/mobile/src/features/cloud/cloud-drafts.ts b/apps/mobile/src/features/cloud/cloud-drafts.ts
index ac313310bc1..e0ff4826deb 100644
--- a/apps/mobile/src/features/cloud/cloud-drafts.ts
+++ b/apps/mobile/src/features/cloud/cloud-drafts.ts
@@ -30,7 +30,13 @@ export const removeCloudEnvironments = createRuntimeCommand(connectionAtomRuntim
);
// Backup failure must retain local file owners so a later sign-in can retry.
yield* Effect.tryPromise({
- try: () => archiveCloudComposerDrafts(accountId, environmentIds),
+ // Resolve draft owners against every environment, not just the removed ones.
+ try: () =>
+ archiveCloudComposerDrafts(
+ accountId,
+ environmentIds,
+ [...entries.values()].map((entry) => entry.target.environmentId),
+ ),
catch: (cause) =>
new CloudDraftArchiveError({
environmentCount: environmentIds.size,
diff --git a/apps/mobile/src/lib/composerAttachmentUploadQueue.test.ts b/apps/mobile/src/lib/composerAttachmentUploadQueue.test.ts
index 31a3e9d0744..6de39c413d4 100644
--- a/apps/mobile/src/lib/composerAttachmentUploadQueue.test.ts
+++ b/apps/mobile/src/lib/composerAttachmentUploadQueue.test.ts
@@ -253,7 +253,7 @@ describe("draft upload scope and offline submission", () => {
const threadId = ThreadId.make("thread:1");
const prefix = questionAttachmentDraftPrefix(environment, threadId);
const key = questionAttachmentDraftKey(environment, threadId, requestId, "question:1");
- expect(composerDraftEnvironmentId(key, [])).toBe(environment);
+ expect(composerDraftEnvironmentId(key, [environment], [])).toBe(environment);
expect(key.startsWith(prefix)).toBe(true);
for (const suffix of ["-extra", ":extra", "/extra", "%extra"]) {
const otherKey = questionAttachmentDraftKey(
@@ -263,20 +263,34 @@ describe("draft upload scope and offline submission", () => {
"question:1",
);
expect(otherKey.startsWith(prefix)).toBe(false);
- expect(composerDraftEnvironmentId(otherKey, [])).toBe(environment);
+ expect(composerDraftEnvironmentId(otherKey, [environment], [])).toBe(environment);
}
}
});
it("resolves thread, new-task, and queued-task drafts without crossing environments", () => {
- expect(composerDraftEnvironmentId("environment-1:thread", [])).toBe(environmentId);
- expect(composerDraftEnvironmentId("new-task:environment-1:project", [])).toBe(environmentId);
+ expect(composerDraftEnvironmentId("environment-1:thread", [environmentId], [])).toBe(
+ environmentId,
+ );
+ expect(composerDraftEnvironmentId("new-task:environment-1:project", [], [])).toBe(
+ environmentId,
+ );
expect(
- composerDraftEnvironmentId("pending-task:message", [{ messageId: "message", environmentId }]),
+ composerDraftEnvironmentId(
+ "pending-task:message",
+ [],
+ [{ messageId: "message", environmentId }],
+ ),
).toBe(environmentId);
- expect(composerDraftEnvironmentId("pending-task:missing", [])).toBeNull();
+ expect(composerDraftEnvironmentId("pending-task:missing", [], [])).toBeNull();
const colonEnvironment = EnvironmentId.make("a:vcs-status:b");
- expect(composerDraftEnvironmentId(`${colonEnvironment}:thread`, [])).toBe(colonEnvironment);
- expect(composerDraftEnvironmentId(`new-task:${colonEnvironment}:project`, [])).toBe(
+ expect(
+ composerDraftEnvironmentId(
+ `${colonEnvironment}:thread`,
+ [EnvironmentId.make("a"), colonEnvironment],
+ [],
+ ),
+ ).toBe(colonEnvironment);
+ expect(composerDraftEnvironmentId(`new-task:${colonEnvironment}:project`, [], [])).toBe(
colonEnvironment,
);
});
@@ -289,9 +303,11 @@ describe("draft upload scope and offline submission", () => {
createdAt: "2026-09-05T00:00:00.000Z",
},
};
- expect(composerDraftEnvironmentId("new-task:abc123-def456", [], stamped)).toBe(environmentId);
- expect(composerDraftEnvironmentId("new-task:abc123-def456", [])).toBeNull();
- expect(composerDraftEnvironmentId("new-task:environment-2:project", [], stamped)).toBe(
+ expect(composerDraftEnvironmentId("new-task:abc123-def456", [], [], stamped)).toBe(
+ environmentId,
+ );
+ expect(composerDraftEnvironmentId("new-task:abc123-def456", [], [])).toBeNull();
+ expect(composerDraftEnvironmentId("new-task:environment-2:project", [], [], stamped)).toBe(
environmentId,
);
});
diff --git a/apps/mobile/src/lib/composerAttachmentUploadQueue.ts b/apps/mobile/src/lib/composerAttachmentUploadQueue.ts
index c20544116b2..72d3eef9c21 100644
--- a/apps/mobile/src/lib/composerAttachmentUploadQueue.ts
+++ b/apps/mobile/src/lib/composerAttachmentUploadQueue.ts
@@ -21,8 +21,10 @@ export function composerAttachmentUploadKey(
return `${environmentId}:${attachmentId}`;
}
+/** Environment and thread ids may both contain colons, so a thread draft key resolves to the longest known environment it starts with. */
export function composerDraftEnvironmentId(
draftKey: string,
+ environmentIds: Iterable<EnvironmentId>,
queuedMessages: ReadonlyArray<{
readonly messageId: string;
readonly environmentId: EnvironmentId;
@@ -42,8 +44,16 @@ export function composerDraftEnvironmentId(
const legacy = parseLegacyNewTaskDraftKey(draftKey);
return legacy === null ? null : EnvironmentId.make(legacy.environmentId);
}
- const separator = draftKey.lastIndexOf(":");
- return separator > 0 ? EnvironmentId.make(draftKey.slice(0, separator)) : null;
+ let match: EnvironmentId | null = null;
+ for (const environmentId of environmentIds) {
+ if (
+ draftKey.startsWith(`${environmentId}:`) &&
+ (match === null || environmentId.length > match.length)
+ ) {
+ match = environmentId;
+ }
+ }
+ return match;
}
type UploadServerConfig = {
diff --git a/apps/mobile/src/lib/composerContextClipboard.test.ts b/apps/mobile/src/lib/composerContextClipboard.test.ts
index afabd7afb55..b3fea2e6ded 100644
--- a/apps/mobile/src/lib/composerContextClipboard.test.ts
+++ b/apps/mobile/src/lib/composerContextClipboard.test.ts
@@ -29,9 +29,15 @@ vi.mock("expo-file-system", () => ({
}));
vi.mock("../state/atom-registry", () => ({
appAtomRegistry: {
- get: () => ({ _tag: "Some", value: { httpBaseUrl: "https://source.example" } }),
+ get: (atom: unknown) =>
+ atom === "environments"
+ ? []
+ : { _tag: "Some", value: { httpBaseUrl: "https://source.example" } },
},
}));
+vi.mock("../state/workspace", () => ({
+ workspaceConnections: { environmentsAtom: "environments" },
+}));
vi.mock("../state/session", () => ({
environmentSession: { preparedConnectionValueAtom: vi.fn() },
}));
diff --git a/apps/mobile/src/lib/composerContextClipboard.ts b/apps/mobile/src/lib/composerContextClipboard.ts
index e7c72018405..971191456cc 100644
--- a/apps/mobile/src/lib/composerContextClipboard.ts
+++ b/apps/mobile/src/lib/composerContextClipboard.ts
@@ -20,6 +20,7 @@ import * as Option from "effect/Option";
import { appAtomRegistry } from "../state/atom-registry";
import { assetEnvironment } from "../state/assets";
import { environmentSession } from "../state/session";
+import { workspaceConnections } from "../state/workspace";
import { downloadAttachmentForPreview } from "./attachmentDownload";
import {
persistComposerAttachmentFile,
@@ -137,7 +138,13 @@ async function importAttachment(
): Promise<DraftComposerAttachment> {
await waitForComposerDraftsLoaded();
checkAborted(signal);
- const local = findLocalComposerClipboardAttachment(environmentId, record.attachmentId);
+ const local = findLocalComposerClipboardAttachment(
+ appAtomRegistry
+ .get(workspaceConnections.environmentsAtom)
+ .map((environment) => environment.environmentId),
+ environmentId,
+ record.attachmentId,
+ );
if (local) {
if (!local.fileUri && local.type === "image" && local.dataUrl)
return {
diff --git a/apps/mobile/src/state/composer-attachment-uploads.test.ts b/apps/mobile/src/state/composer-attachment-uploads.test.ts
index fefdb151f5f..1809acc559b 100644
--- a/apps/mobile/src/state/composer-attachment-uploads.test.ts
+++ b/apps/mobile/src/state/composer-attachment-uploads.test.ts
@@ -102,7 +102,12 @@ vi.mock("./entities", () => ({
useVisibleThreadShells: () => [],
}));
vi.mock("./projects", () => ({ environmentProjects: {} }));
-vi.mock("./workspace", () => ({ workspaceConnections: {} }));
+vi.mock("./workspace", async () => {
+ const { Atom } = await import("effect/reactivity");
+ return {
+ workspaceConnections: { environmentsAtom: Atom.make([{ environmentId: "environment-1" }]) },
+ };
+});
vi.mock("./server", async () => {
const { Atom } = await import("effect/reactivity");
return { serverEnvironment: { configValueAtom: Atom.family(() => Atom.make(null)) } };
@@ -210,6 +215,7 @@ const requestsAtom = Atom.make((get) =>
composerAttachmentUploadRequests({
drafts: get(drafts.composerDraftUploadSourcesAtom),
queuedMessagesByThreadKey: get(threadOutboxManager.queuedMessagesByThreadKeyAtom),
+ knownEnvironmentIds: [environmentId],
connectedEnvironmentIds: new Set([environmentId]),
operableEnvironmentIds: new Set([environmentId]),
serverConfigs: new Map([[environmentId, config]]),
@@ -337,3 +343,37 @@ it("keeps an unexpected draft flush error blocking Send", async () => {
);
expect(native.deleted).toEqual(["pending-1"]);
});
+
+it("uploads draft attachments for threads whose ids contain colons", () => {
+ const keys = [
+ "environment-1:thread-1",
+ "environment-1:thread:mcp:namespace:key:0",
+ "environment-1:command-1:fork",
+ "environment-1:thread-1~queued-edit~run:1",
+ ];
+ const requests = composerAttachmentUploadRequests({
+ drafts: Object.fromEntries(keys.map((key) => [key, { attachments: [{ ...image, id: key }] }])),
+ queuedMessagesByThreadKey: {},
+ knownEnvironmentIds: [environmentId],
+ connectedEnvironmentIds: new Set([environmentId]),
+ operableEnvironmentIds: new Set([environmentId]),
+ serverConfigs: new Map([[environmentId, config]]),
+ });
+ expect(requests.map((request) => [request.attachment.id, request.environmentId])).toEqual(
+ keys.map((key) => [key, environmentId]),
+ );
+});
+
+it("does not upload a disconnected colon environment's draft to its connected prefix", () => {
+ const connected = EnvironmentId.make("a");
+ const disconnected = EnvironmentId.make("a:vcs-status:b");
+ const requests = composerAttachmentUploadRequests({
+ drafts: { [`${disconnected}:thread-1`]: { attachments: [image] } },
+ queuedMessagesByThreadKey: {},
+ knownEnvironmentIds: [connected, disconnected],
+ connectedEnvironmentIds: new Set([connected]),
+ operableEnvironmentIds: new Set([connected]),
+ serverConfigs: new Map([[connected, config]]),
+ });
+ expect(requests).toEqual([]);
+});
diff --git a/apps/mobile/src/state/composer-attachment-uploads.ts b/apps/mobile/src/state/composer-attachment-uploads.ts
index 7bf7747fef2..2618786dae1 100644
--- a/apps/mobile/src/state/composer-attachment-uploads.ts
+++ b/apps/mobile/src/state/composer-attachment-uploads.ts
@@ -66,6 +66,8 @@ type ComposerAttachmentUploadRequest = {
export function composerAttachmentUploadRequests(input: {
readonly drafts: Readonly<Record<string, Pick<ComposerDraft, "attachments" | "project">>>;
readonly queuedMessagesByThreadKey: Parameters<typeof flattenQueuedThreadMessages>[0];
+ /** Every environment the client knows, so a draft key never resolves to a shorter connected prefix. */
+ readonly knownEnvironmentIds: Iterable<EnvironmentId>;
readonly connectedEnvironmentIds: ReadonlySet<EnvironmentId>;
readonly operableEnvironmentIds: ReadonlySet<EnvironmentId>;
readonly serverConfigs: ReadonlyMap<
@@ -75,7 +77,7 @@ export function composerAttachmentUploadRequests(input: {
}): ReadonlyArray<ComposerAttachmentUploadRequest> {
const queued = flattenQueuedThreadMessages(input.queuedMessagesByThreadKey);
return Object.entries(input.drafts).flatMap(([key, draft]) => {
- const environmentId = composerDraftEnvironmentId(key, queued, draft);
+ const environmentId = composerDraftEnvironmentId(key, input.knownEnvironmentIds, queued, draft);
if (
environmentId === null ||
!input.connectedEnvironmentIds.has(environmentId) ||
@@ -93,7 +95,8 @@ export function composerAttachmentUploadRequests(input: {
// Each connected environment's session is read here so a granted or revoked
// operate scope re-syncs the queue.
const composerAttachmentUploadRequestsAtom = Atom.make((get) => {
- const connected = get(workspaceConnections.environmentsAtom).filter(
+ const environments = get(workspaceConnections.environmentsAtom);
+ const connected = environments.filter(
(environment) => environment.connectionState === "connected",
);
const operableEnvironmentIds = new Set<EnvironmentId>();
@@ -110,6 +113,7 @@ const composerAttachmentUploadRequestsAtom = Atom.make((get) => {
return composerAttachmentUploadRequests({
drafts: get(composerDraftUploadSourcesAtom),
queuedMessagesByThreadKey: get(threadOutboxManager.queuedMessagesByThreadKeyAtom),
+ knownEnvironmentIds: environments.map((environment) => environment.environmentId),
connectedEnvironmentIds: new Set(connected.map((environment) => environment.environmentId)),
operableEnvironmentIds,
serverConfigs: get(environmentServerConfigsAtom),
@@ -144,10 +148,14 @@ export function createComposerAttachmentUploadWorker(
const queued = flattenQueuedThreadMessages(
appAtomRegistry.get(threadOutboxManager.queuedMessagesByThreadKeyAtom),
);
+ const knownEnvironmentIds = appAtomRegistry
+ .get(workspaceConnections.environmentsAtom)
+ .map((environment) => environment.environmentId);
let retained = false;
for (const [key, draft] of Object.entries(appAtomRegistry.get(composerDraftsAtom))) {
if (
- composerDraftEnvironmentId(key, queued, draft) === environmentId &&
+ composerDraftEnvironmentId(key, knownEnvironmentIds, queued, draft) ===
+ environmentId &&
draft.attachments.some((candidate) => candidate.id === attachment.id)
) {
retained = setComposerDraftAttachmentUpload(key, uploaded) || retained;
diff --git a/apps/mobile/src/state/queued-edit-draft-key.ts b/apps/mobile/src/state/queued-edit-draft-key.ts
index f9b8027ba6c..ad12a304662 100644
--- a/apps/mobile/src/state/queued-edit-draft-key.ts
+++ b/apps/mobile/src/state/queued-edit-draft-key.ts
@@ -1,4 +1,4 @@
-/** Keep edit keys separate to preserve original drafts; the marker cannot contain colons because environment parsing uses the last one. */
+/** Keep edit keys separate to preserve original drafts. */
const QUEUED_EDIT_DRAFT_MARKER = "~queued-edit~";
export function queuedEditDraftKey(threadKey: string, runId: string): string {
diff --git a/apps/mobile/src/state/threadOutboxDelivery.test.ts b/apps/mobile/src/state/threadOutboxDelivery.test.ts
index d77ffe1942b..8fafbe62e71 100644
--- a/apps/mobile/src/state/threadOutboxDelivery.test.ts
+++ b/apps/mobile/src/state/threadOutboxDelivery.test.ts
@@ -367,7 +367,9 @@ describe("thread outbox drain delivery cleanup", () => {
it("removes an acknowledged outbox item even when the sign-out archive write fails", async () => {
const message = queuedMessage({ messageId: "archive-write-failure", text: "Delivered" });
await harness.manager.enqueue(message);
- await composerDrafts.archiveCloudComposerDrafts("account-a", new Set([message.environmentId]));
+ await composerDrafts.archiveCloudComposerDrafts("account-a", new Set([message.environmentId]), [
+ message.environmentId,
+ ]);
harness.draftFile.setWriteError(new Error("Draft storage unavailable"));
await expect(
@@ -399,6 +401,7 @@ describe("thread outbox drain delivery cleanup", () => {
await composerDrafts.archiveCloudComposerDrafts(
"account-a",
new Set([message.environmentId]),
+ [message.environmentId],
);
expect(
appAtomRegistry.get(composerDrafts.composerCloudDraftsAtom).signedOut["account-a"]
@@ -426,7 +429,9 @@ describe("thread outbox drain delivery cleanup", () => {
const deliveryRevision = harness.manager.revisionOf(message.messageId);
const edited = { ...message, text: "Keep this edit" };
await harness.manager.update(edited);
- await composerDrafts.archiveCloudComposerDrafts("account-a", new Set([message.environmentId]));
+ await composerDrafts.archiveCloudComposerDrafts("account-a", new Set([message.environmentId]), [
+ message.environmentId,
+ ]);
await harness.manager.clearEnvironment(message.environmentId);
await expect(completeQueuedMessageDelivery(message, deliveryRevision, undefined)).resolves.toBe(
"edited",
diff --git a/apps/mobile/src/state/use-composer-drafts.test.ts b/apps/mobile/src/state/use-composer-drafts.test.ts
index 868901f81f7..1f9345da828 100644
--- a/apps/mobile/src/state/use-composer-drafts.test.ts
+++ b/apps/mobile/src/state/use-composer-drafts.test.ts
@@ -1281,7 +1281,10 @@ describe("mobile composer drafts", () => {
"pending-task:queued-1": { text: "Edited queued task", attachments: [file] },
});
appAtomRegistry.set(threadOutboxManager.queuedMessagesByThreadKeyAtom, { queued: [queued] });
- await archiveCloudComposerDrafts("account-a", new Set([environmentId]));
+ await archiveCloudComposerDrafts("account-a", new Set([environmentId]), [
+ environmentId,
+ EnvironmentId.make("direct-environment"),
+ ]);
expect(appAtomRegistry.get(composerDraftsAtom)).toEqual({
"direct-environment:thread-1": DRAFT,
});
@@ -1347,7 +1350,9 @@ describe("mobile composer drafts", () => {
appAtomRegistry.set(composerDraftsAtom, { "environment-1:thread-1": DRAFT });
composerDraftFileMocks.setWriteError(new Error("Storage is full"));
await expect(
- archiveCloudComposerDrafts("account-a", new Set([EnvironmentId.make("environment-1")])),
+ archiveCloudComposerDrafts("account-a", new Set([EnvironmentId.make("environment-1")]), [
+ EnvironmentId.make("environment-1"),
+ ]),
).rejects.toThrow();
expect(
appAtomRegistry.get(composerCloudDraftsAtom).signedOut["account-a"]?.drafts[
@@ -1356,7 +1361,9 @@ describe("mobile composer drafts", () => {
).toEqual(DRAFT);
expect(composerAttachmentCleanupMocks.remove).not.toHaveBeenCalled();
composerDraftFileMocks.setWriteError(null);
- await archiveCloudComposerDrafts(null, new Set([EnvironmentId.make("environment-1")]));
+ await archiveCloudComposerDrafts(null, new Set([EnvironmentId.make("environment-1")]), [
+ EnvironmentId.make("environment-1"),
+ ]);
expect(
decodePersistedComposerState(JSON.parse(composerDraftFileMocks.getDocument())).cloudDrafts
.signedOut["account-a"]?.drafts["environment-1:thread-1"],
diff --git a/apps/mobile/src/state/use-composer-drafts.ts b/apps/mobile/src/state/use-composer-drafts.ts
index 791383be9e7..4e7d96de3b1 100644
--- a/apps/mobile/src/state/use-composer-drafts.ts
+++ b/apps/mobile/src/state/use-composer-drafts.ts
@@ -828,6 +828,7 @@ function signedOutAttachmentOwners() {
}
export function findLocalComposerClipboardAttachment(
+ knownEnvironmentIds: Iterable<EnvironmentId>,
environmentId: EnvironmentId,
id: string,
): DraftComposerAttachment | undefined {
@@ -835,7 +836,10 @@ export function findLocalComposerClipboardAttachment(
appAtomRegistry.get(threadOutboxManager.queuedMessagesByThreadKeyAtom),
).flat();
for (const [key, draft] of Object.entries(appAtomRegistry.get(composerDraftsAtom))) {
- if (composerDraftEnvironmentId(key, queuedMessages, draft) !== environmentId) continue;
+ if (
+ composerDraftEnvironmentId(key, knownEnvironmentIds, queuedMessages, draft) !== environmentId
+ )
+ continue;
const attachment = draft.attachments.find((entry) => entry.id === id);
if (attachment) return attachment;
}
@@ -1084,6 +1088,7 @@ export async function getComposerCloudAccountId(): Promise<string | null> {
export async function archiveCloudComposerDrafts(
accountId: string | null,
environmentIds: ReadonlySet<EnvironmentId>,
+ knownEnvironmentIds: Iterable<EnvironmentId>,
): Promise<void> {
await waitForComposerDraftsLoaded();
if (!(await threadOutboxManager.load())) throw new Error("Could not preserve queued messages.");
@@ -1098,7 +1103,7 @@ export async function archiveCloudComposerDrafts(
const remaining = { ...current };
const savedDrafts = { ...cloud.signedOut[owner]?.drafts };
for (const [key, draft] of Object.entries(current)) {
- const environmentId = composerDraftEnvironmentId(key, queued, draft);
+ const environmentId = composerDraftEnvironmentId(key, knownEnvironmentIds, queued, draft);
if (environmentId !== null && environmentIds.has(environmentId)) {
savedDrafts[key] = draft;
delete remaining[key];