Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
import {
scopedProjectKey,
scopeProjectRef,
scopeThreadRef,
} from "@akeru/client-runtime/environment";
import { ProjectId, ThreadId } from "@akeru/contracts";
import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
import {
clearComposerDraftsEnvironment,
finalizePromotedDraftThreadByRef,
markPromotedDraftThread,
markPromotedDraftThreadByRef,
markPromotedDraftThreads,
markPromotedDraftThreadsByRef,
useComposerDraftStore,
DraftId,
} from "./composerDraftStore";
import {
TEST_ENVIRONMENT_ID,
OTHER_TEST_ENVIRONMENT_ID,
resetComposerDraftStore,
makeImage,
draftByKey,
draftFor,
} from "./composerDraftStore.test-support";
describe("composerDraftStore project draft thread mapping", () => {
const projectId = ProjectId.make("project-a");
const otherProjectId = ProjectId.make("project-b");
const projectRef = scopeProjectRef(TEST_ENVIRONMENT_ID, projectId);
const otherProjectRef = scopeProjectRef(TEST_ENVIRONMENT_ID, otherProjectId);
const remoteProjectRef = scopeProjectRef(OTHER_TEST_ENVIRONMENT_ID, projectId);
const threadId = ThreadId.make("thread-a");
const otherThreadId = ThreadId.make("thread-b");
const draftId = DraftId.make("draft-a");
const otherDraftId = DraftId.make("draft-b");
const sharedDraftId = DraftId.make("draft-shared");
const localDraftId = DraftId.make("draft-local");
const remoteDraftId = DraftId.make("draft-remote");
beforeEach(() => {
resetComposerDraftStore();
});
it("clears composer data for one environment without touching another", () => {
const store = useComposerDraftStore.getState();
const localThreadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
const remoteThreadRef = scopeThreadRef(OTHER_TEST_ENVIRONMENT_ID, otherThreadId);
const originalRevokeObjectUrl = URL.revokeObjectURL;
const revokeSpy = vi.fn<(url: string) => void>();
URL.revokeObjectURL = revokeSpy;
try {
store.setProjectDraftThreadId(projectRef, localDraftId, { threadId });
store.setProjectDraftThreadId(remoteProjectRef, remoteDraftId, {
threadId: otherThreadId,
});
store.setPrompt(localDraftId, "local draft");
store.setPrompt(remoteDraftId, "remote draft");
store.addImage(localDraftId, makeImage({ id: "img-local", previewUrl: "blob:local-draft" }));
store.setPrompt(localThreadRef, "local thread draft");
store.setPrompt(remoteThreadRef, "remote thread draft");
clearComposerDraftsEnvironment(TEST_ENVIRONMENT_ID);
const next = useComposerDraftStore.getState();
expect(next.getDraftThreadByProjectRef(projectRef)).toBeNull();
expect(next.getDraftThreadByProjectRef(remoteProjectRef)).not.toBeNull();
expect(next.getComposerDraft(localDraftId)).toBeNull();
expect(next.getComposerDraft(remoteDraftId)?.prompt).toBe("remote thread draft");
expect(next.getComposerDraft(localThreadRef)).toBeNull();
expect(next.getComposerDraft(remoteThreadRef)?.prompt).toBe("remote thread draft");
expect(revokeSpy).toHaveBeenCalledWith("blob:local-draft");
} finally {
URL.revokeObjectURL = originalRevokeObjectUrl;
}
});
it("stores and reads project draft thread ids via actions", () => {
const store = useComposerDraftStore.getState();
expect(store.getDraftThreadByProjectRef(projectRef)).toBeNull();
expect(store.getDraftThread(draftId)).toBeNull();
store.setProjectDraftThreadId(projectRef, draftId, {
threadId,
branch: "feature/test",
worktreePath: "/tmp/worktree-test",
createdAt: "2026-01-01T00:00:00.000Z",
});
expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toMatchObject({
threadId,
environmentId: TEST_ENVIRONMENT_ID,
projectId,
logicalProjectKey: scopedProjectKey(projectRef),
branch: "feature/test",
worktreePath: "/tmp/worktree-test",
envMode: "worktree",
runtimeMode: "auto",
interactionMode: "default",
createdAt: "2026-01-01T00:00:00.000Z",
});
expect(useComposerDraftStore.getState().getDraftThread(draftId)).toMatchObject({
environmentId: TEST_ENVIRONMENT_ID,
projectId,
logicalProjectKey: scopedProjectKey(projectRef),
branch: "feature/test",
worktreePath: "/tmp/worktree-test",
envMode: "worktree",
runtimeMode: "auto",
interactionMode: "default",
createdAt: "2026-01-01T00:00:00.000Z",
});
});
it("rotates a failed bootstrap thread id without losing its draft", () => {
const store = useComposerDraftStore.getState();
const retryThreadId = ThreadId.make("thread-retry");
store.setProjectDraftThreadId(projectRef, draftId, {
threadId,
branch: "feature/test",
worktreePath: null,
createdAt: "2026-01-01T00:00:00.000Z",
envMode: "worktree",
startFromOrigin: true,
runtimeMode: "approval-required",
interactionMode: "plan",
});
store.setPrompt(draftId, "keep this prompt");
markPromotedDraftThread(threadId);
store.setLogicalProjectDraftThreadId(scopedProjectKey(projectRef), projectRef, draftId, {
threadId: retryThreadId,
createdAt: "2026-01-01T00:01:00.000Z",
});
expect(useComposerDraftStore.getState().getDraftThread(draftId)).toMatchObject({
threadId: retryThreadId,
branch: "feature/test",
worktreePath: null,
createdAt: "2026-01-01T00:01:00.000Z",
envMode: "worktree",
startFromOrigin: true,
runtimeMode: "approval-required",
interactionMode: "plan",
promotedTo: null,
});
expect(useComposerDraftStore.getState().getComposerDraft(draftId)?.prompt).toBe(
"keep this prompt",
);
});
it("clears only matching project draft mapping entries", () => {
const store = useComposerDraftStore.getState();
store.setProjectDraftThreadId(projectRef, draftId, { threadId });
store.setPrompt(draftId, "hello");
store.clearProjectDraftThreadById(projectRef, otherDraftId);
expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)?.threadId).toBe(
threadId,
);
store.clearProjectDraftThreadById(projectRef, draftId);
expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toBeNull();
expect(useComposerDraftStore.getState().getDraftThread(draftId)).toBeNull();
expect(draftByKey(draftId)).toBeUndefined();
});
it("clears project draft mapping by project id", () => {
const store = useComposerDraftStore.getState();
store.setProjectDraftThreadId(projectRef, draftId, { threadId });
store.setPrompt(draftId, "hello");
store.clearProjectDraftThreadId(projectRef);
expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toBeNull();
expect(useComposerDraftStore.getState().getDraftThread(draftId)).toBeNull();
expect(draftByKey(draftId)).toBeUndefined();
});
it("revokes draft image blob URLs when clearing a project's draft thread", () => {
const store = useComposerDraftStore.getState();
const originalRevokeObjectUrl = URL.revokeObjectURL;
const revokeSpy = vi.fn<(url: string) => void>();
URL.revokeObjectURL = revokeSpy;
try {
store.setProjectDraftThreadId(projectRef, draftId, { threadId });
store.addImage(draftId, makeImage({ id: "img-project-clear", previewUrl: "blob:clear" }));
store.clearProjectDraftThreadId(projectRef);
expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toBeNull();
expect(useComposerDraftStore.getState().getDraftThread(draftId)).toBeNull();
expect(revokeSpy).toHaveBeenCalledWith("blob:clear");
} finally {
URL.revokeObjectURL = originalRevokeObjectUrl;
}
});
it("revokes draft image blob URLs when clearing a matching project draft thread by id", () => {
const store = useComposerDraftStore.getState();
const originalRevokeObjectUrl = URL.revokeObjectURL;
const revokeSpy = vi.fn<(url: string) => void>();
URL.revokeObjectURL = revokeSpy;
try {
store.setProjectDraftThreadId(projectRef, draftId, { threadId });
store.addImage(
draftId,
makeImage({ id: "img-project-clear-by-id", previewUrl: "blob:clear-by-id" }),
);
store.clearProjectDraftThreadById(projectRef, draftId);
expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toBeNull();
expect(useComposerDraftStore.getState().getDraftThread(draftId)).toBeNull();
expect(revokeSpy).toHaveBeenCalledWith("blob:clear-by-id");
} finally {
URL.revokeObjectURL = originalRevokeObjectUrl;
}
});
it("clears empty composer drafts when remapping a project to a new draft thread", () => {
const store = useComposerDraftStore.getState();
store.setProjectDraftThreadId(projectRef, draftId, { threadId });
store.setProjectDraftThreadId(projectRef, otherDraftId, { threadId: otherThreadId });
expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)?.threadId).toBe(
otherThreadId,
);
expect(useComposerDraftStore.getState().getDraftThread(draftId)).toBeNull();
expect(draftByKey(draftId)).toBeUndefined();
});
it("keeps invested composer drafts alive unmapped when remapping a project to a new draft thread", () => {
const store = useComposerDraftStore.getState();
store.setProjectDraftThreadId(projectRef, draftId, { threadId });
store.setPrompt(draftId, "keep me around");
store.setProjectDraftThreadId(projectRef, otherDraftId, { threadId: otherThreadId });
// The mapping moved to the fresh draft...
expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)?.threadId).toBe(
otherThreadId,
);
// ...but the invested draft survives with its content for the sidebar
// draft rows to surface.
expect(useComposerDraftStore.getState().getDraftThread(draftId)?.threadId).toBe(threadId);
expect(draftByKey(draftId)?.prompt).toBe("keep me around");
});
it("clears every session for a project, including unmapped invested drafts", () => {
const store = useComposerDraftStore.getState();
store.setProjectDraftThreadId(projectRef, draftId, { threadId });
store.setPrompt(draftId, "invested");
// The remap leaves the invested draft alive unmapped; project removal
// must still sweep it, or its sidebar row outlives the project.
store.setProjectDraftThreadId(projectRef, otherDraftId, { threadId: otherThreadId });
store.clearProjectDraftThreadId(projectRef);
expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toBeNull();
expect(useComposerDraftStore.getState().getDraftThread(draftId)).toBeNull();
expect(useComposerDraftStore.getState().getDraftThread(otherDraftId)).toBeNull();
expect(draftByKey(draftId)).toBeUndefined();
});
it("keeps composer drafts when the thread is still mapped by another project", () => {
const store = useComposerDraftStore.getState();
store.setProjectDraftThreadId(projectRef, draftId, { threadId });
store.setProjectDraftThreadId(otherProjectRef, sharedDraftId, { threadId });
store.setPrompt(sharedDraftId, "keep me");
store.clearProjectDraftThreadId(projectRef);
expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toBeNull();
expect(
useComposerDraftStore.getState().getDraftThreadByProjectRef(otherProjectRef)?.threadId,
).toBe(threadId);
expect(draftByKey(sharedDraftId)?.prompt).toBe("keep me");
});
it("clears draft registration independently", () => {
const store = useComposerDraftStore.getState();
store.setProjectDraftThreadId(projectRef, draftId, { threadId });
store.setPrompt(draftId, "remove me");
store.clearDraftThread(draftId);
expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toBeNull();
expect(useComposerDraftStore.getState().getDraftThread(draftId)).toBeNull();
expect(draftByKey(draftId)).toBeUndefined();
});
it("marks a promoted draft by thread id without deleting composer state", () => {
const store = useComposerDraftStore.getState();
store.setProjectDraftThreadId(projectRef, draftId, { threadId });
store.setPrompt(draftId, "promote me");
markPromotedDraftThread(threadId);
expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toBeNull();
expect(useComposerDraftStore.getState().getDraftThread(draftId)?.promotedTo).toEqual(
scopeThreadRef(TEST_ENVIRONMENT_ID, threadId),
);
expect(draftByKey(draftId)?.prompt).toBe("promote me");
});
it("reads local draft composer state through a scoped thread ref", () => {
const store = useComposerDraftStore.getState();
const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
store.setProjectDraftThreadId(projectRef, draftId, { threadId });
store.setPrompt(draftId, "scoped access");
expect(store.getComposerDraft(draftId)?.prompt).toBe("scoped access");
expect(store.getComposerDraft(threadRef)?.prompt).toBe("scoped access");
});
it("does not clear composer drafts for existing server threads during promotion cleanup", () => {
const store = useComposerDraftStore.getState();
const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
store.setPrompt(threadRef, "keep me");
markPromotedDraftThread(threadId);
expect(useComposerDraftStore.getState().getDraftThread(threadRef)).toBeNull();
expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.prompt).toBe("keep me");
});
it("marks promoted drafts from an iterable of server thread ids", () => {
const store = useComposerDraftStore.getState();
store.setProjectDraftThreadId(projectRef, draftId, { threadId });
store.setPrompt(draftId, "promote me");
store.setProjectDraftThreadId(otherProjectRef, otherDraftId, { threadId: otherThreadId });
store.setPrompt(otherDraftId, "keep me");
markPromotedDraftThreads([threadId]);
expect(useComposerDraftStore.getState().getDraftThread(draftId)?.promotedTo).toEqual(
scopeThreadRef(TEST_ENVIRONMENT_ID, threadId),
);
expect(draftByKey(draftId)?.prompt).toBe("promote me");
expect(
useComposerDraftStore.getState().getDraftThreadByProjectRef(otherProjectRef)?.threadId,
).toBe(otherThreadId);
expect(draftByKey(otherDraftId)?.prompt).toBe("keep me");
});
it("marks every matching scoped draft when multiple environments share a thread id", () => {
const store = useComposerDraftStore.getState();
const localThreadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
const remoteThreadRef = scopeThreadRef(OTHER_TEST_ENVIRONMENT_ID, threadId);
store.setProjectDraftThreadId(projectRef, localDraftId, { threadId });
store.setPrompt(localDraftId, "local draft");
store.setProjectDraftThreadId(remoteProjectRef, remoteDraftId, { threadId });
store.setPrompt(remoteDraftId, "remote draft");
markPromotedDraftThread(threadId);
expect(store.getDraftThreadByProjectRef(projectRef)).toBeNull();
expect(store.getDraftThreadByProjectRef(remoteProjectRef)).toBeNull();
expect(store.getDraftThreadByRef(localThreadRef)?.promotedTo).toEqual(localThreadRef);
expect(store.getDraftThreadByRef(remoteThreadRef)?.promotedTo).toEqual(remoteThreadRef);
expect(draftByKey(localDraftId)?.prompt).toBe("local draft");
expect(draftByKey(remoteDraftId)?.prompt).toBe("remote draft");
});
it("only marks promoted drafts for the matching environment ref", () => {
const store = useComposerDraftStore.getState();
store.setProjectDraftThreadId(projectRef, draftId, { threadId });
store.setPrompt(draftId, "promote me");
markPromotedDraftThreadByRef(scopeThreadRef(OTHER_TEST_ENVIRONMENT_ID, threadId));
expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)?.threadId).toBe(
threadId,
);
expect(draftByKey(draftId)?.prompt).toBe("promote me");
});
it("only marks iterable promotion cleanup entries for the matching environment refs", () => {
const store = useComposerDraftStore.getState();
store.setProjectDraftThreadId(projectRef, draftId, { threadId });
store.setPrompt(draftId, "promote me");
markPromotedDraftThreadsByRef([scopeThreadRef(OTHER_TEST_ENVIRONMENT_ID, threadId)]);
expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)?.threadId).toBe(
threadId,
);
expect(draftByKey(draftId)?.prompt).toBe("promote me");
});
it("keeps existing server-thread composer drafts during iterable promotion cleanup", () => {
const store = useComposerDraftStore.getState();
const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
store.setPrompt(threadRef, "keep me");
markPromotedDraftThreads([threadId]);
expect(useComposerDraftStore.getState().getDraftThread(threadRef)).toBeNull();
expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.prompt).toBe("keep me");
});
it("finalizes a promoted draft after the canonical thread route is active", () => {
const store = useComposerDraftStore.getState();
store.setProjectDraftThreadId(projectRef, draftId, { threadId });
store.setPrompt(draftId, "promote me");
markPromotedDraftThread(threadId);
finalizePromotedDraftThreadByRef(scopeThreadRef(TEST_ENVIRONMENT_ID, threadId));
expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toBeNull();
expect(useComposerDraftStore.getState().getDraftThread(draftId)).toBeNull();
expect(draftByKey(draftId)).toBeUndefined();
});
it("finalizes a matching materialized draft even when promotion was not pre-marked", () => {
const store = useComposerDraftStore.getState();
store.setProjectDraftThreadId(projectRef, draftId, { threadId });
store.setPrompt(draftId, "promote me");
finalizePromotedDraftThreadByRef(scopeThreadRef(TEST_ENVIRONMENT_ID, threadId));
expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toBeNull();
expect(useComposerDraftStore.getState().getDraftThread(draftId)).toBeNull();
expect(draftByKey(draftId)).toBeUndefined();
});
it("updates branch context on an existing draft thread", () => {
const store = useComposerDraftStore.getState();
store.setProjectDraftThreadId(projectRef, draftId, {
threadId,
branch: "main",
worktreePath: null,
});
store.setDraftThreadContext(draftId, {
branch: "feature/next",
worktreePath: "/tmp/feature-next",
});
expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)?.threadId).toBe(
threadId,
);
expect(useComposerDraftStore.getState().getDraftThread(draftId)).toMatchObject({
environmentId: TEST_ENVIRONMENT_ID,
projectId,
branch: "feature/next",
worktreePath: "/tmp/feature-next",
envMode: "worktree",
});
});
it("stores the start-from-origin choice with the draft thread", () => {
const store = useComposerDraftStore.getState();
store.setProjectDraftThreadId(projectRef, draftId, {
threadId,
envMode: "worktree",
startFromOrigin: true,
});
expect(useComposerDraftStore.getState().getDraftThread(draftId)?.startFromOrigin).toBe(true);
store.setDraftThreadContext(draftId, { startFromOrigin: false });
expect(useComposerDraftStore.getState().getDraftThread(draftId)?.startFromOrigin).toBe(false);
});
it("preserves existing branch and worktree when setProjectDraftThreadId receives undefined", () => {
const store = useComposerDraftStore.getState();
store.setProjectDraftThreadId(projectRef, draftId, {
threadId,
branch: "main",
worktreePath: "/tmp/main-worktree",
});
const runtimeUndefinedOptions = {
branch: undefined,
worktreePath: undefined,
};
store.setProjectDraftThreadId(projectRef, draftId, runtimeUndefinedOptions);
expect(useComposerDraftStore.getState().getDraftThread(draftId)).toMatchObject({
environmentId: TEST_ENVIRONMENT_ID,
projectId,
branch: "main",
worktreePath: "/tmp/main-worktree",
envMode: "worktree",
});
});
it("preserves worktree env mode without a worktree path", () => {
const store = useComposerDraftStore.getState();
store.setProjectDraftThreadId(projectRef, draftId, {
threadId,
branch: "feature/base",
worktreePath: null,
envMode: "worktree",
});
const runtimeUndefinedOptions = {
branch: undefined,
worktreePath: undefined,
envMode: undefined,
};
store.setProjectDraftThreadId(projectRef, draftId, runtimeUndefinedOptions);
expect(useComposerDraftStore.getState().getDraftThread(draftId)).toMatchObject({
environmentId: TEST_ENVIRONMENT_ID,
projectId,
branch: "feature/base",
worktreePath: null,
envMode: "worktree",
});
});
it("clears branch and worktree but keeps env mode when remapping a draft to another environment", () => {
const store = useComposerDraftStore.getState();
store.setProjectDraftThreadId(projectRef, draftId, {
threadId,
branch: "feature/local-only",
worktreePath: "/tmp/local-worktree",
envMode: "worktree",
startFromOrigin: true,
});
store.setLogicalProjectDraftThreadId(scopedProjectKey(projectRef), remoteProjectRef, draftId, {
threadId,
});
expect(useComposerDraftStore.getState().getDraftThread(draftId)).toMatchObject({
environmentId: OTHER_TEST_ENVIRONMENT_ID,
projectId,
branch: null,
worktreePath: null,
envMode: "worktree",
startFromOrigin: true,
});
});
it("clears branch and worktree but keeps env mode when changing a draft thread project ref", () => {
const store = useComposerDraftStore.getState();
store.setProjectDraftThreadId(projectRef, draftId, {
threadId,
branch: "feature/local-only",
worktreePath: "/tmp/local-worktree",
envMode: "worktree",
startFromOrigin: true,
});
store.setDraftThreadContext(draftId, {
projectRef: remoteProjectRef,
});
expect(useComposerDraftStore.getState().getDraftThread(draftId)).toMatchObject({
environmentId: OTHER_TEST_ENVIRONMENT_ID,
projectId,
branch: null,
worktreePath: null,
envMode: "worktree",
startFromOrigin: true,
});
});
});