@clinebot/core 0.0.10 → 0.0.12

package/src/session/default-session-manager.test.ts

@@ -2,7 +2,8 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { AgentResult } from "@clinebot/agents";
-import { describe, expect, it, vi } from "vitest";
+import { setClineDir, setHomeDir } from "@clinebot/shared/storage";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { TelemetryService } from "../telemetry/TelemetryService";
 import { SessionSource } from "../types/common";
 import type { CoreSessionConfig } from "../types/config";
@@ -55,6 +56,61 @@ function createManifest(sessionId: string): SessionManifest {
 	};
 }
 
+type PluginEventTestHarness = {
+	handlePluginEvent: (
+		rootSessionId: string,
+		event: { name: string; payload?: unknown },
+	) => Promise<void>;
+	getPendingPrompts: (
+		sessionId: string,
+	) => Array<{ prompt: string; delivery: "queue" | "steer" }>;
+};
+
+function createPluginEventHarness(
+	manager: DefaultSessionManager,
+): PluginEventTestHarness {
+	const target = manager as object;
+	return {
+		handlePluginEvent: async (rootSessionId, event) => {
+			const handler = Reflect.get(target, "handlePluginEvent");
+			if (typeof handler !== "function") {
+				throw new Error("handlePluginEvent test hook unavailable");
+			}
+			await Reflect.apply(
+				handler as (
+					rootSessionId: string,
+					event: { name: string; payload?: unknown },
+				) => Promise<void>,
+				target,
+				[rootSessionId, event],
+			);
+		},
+		getPendingPrompts: (sessionId) => {
+			const getter = Reflect.get(target, "getSessionOrThrow");
+			if (typeof getter !== "function") {
+				throw new Error("getSessionOrThrow test hook unavailable");
+			}
+			const session = Reflect.apply(
+				getter as (sessionId: string) => {
+					pendingPrompts: Array<{
+						id: string;
+						prompt: string;
+						delivery: "queue" | "steer";
+						userFiles?: unknown;
+						userImages?: unknown;
+					}>;
+				},
+				target,
+				[sessionId],
+			);
+			return session.pendingPrompts.map(({ prompt, delivery }) => ({
+				prompt,
+				delivery,
+			}));
+		},
+	};
+}
+
 function createConfig(
 	overrides: Partial<CoreSessionConfig> = {},
 ): CoreSessionConfig {
@@ -71,6 +127,28 @@ function createConfig(
 }
 
 describe("DefaultSessionManager", () => {
+	const envSnapshot = {
+		HOME: process.env.HOME,
+		CLINE_DIR: process.env.CLINE_DIR,
+	};
+	let isolatedHomeDir = "";
+
+	beforeEach(() => {
+		isolatedHomeDir = mkdtempSync(join(tmpdir(), "core-session-home-"));
+		process.env.HOME = isolatedHomeDir;
+		process.env.CLINE_DIR = join(isolatedHomeDir, ".cline");
+		setHomeDir(isolatedHomeDir);
+		setClineDir(process.env.CLINE_DIR);
+	});
+
+	afterEach(() => {
+		process.env.HOME = envSnapshot.HOME;
+		process.env.CLINE_DIR = envSnapshot.CLINE_DIR;
+		setHomeDir(envSnapshot.HOME ?? "~");
+		setClineDir(envSnapshot.CLINE_DIR ?? join("~", ".cline"));
+		rmSync(isolatedHomeDir, { recursive: true, force: true });
+	});
+
 	it("emits session lifecycle telemetry when configured", async () => {
 		const sessionId = "sess-telemetry";
 		const manifest = createManifest(sessionId);
@@ -309,6 +387,294 @@ describe("DefaultSessionManager", () => {
 		});
 	});
 
+	it("queues sandbox steer messages back into the active session", async () => {
+		const sessionId = "sess-steer";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest.json",
+				transcriptPath: "/tmp/transcript.log",
+				hookPath: "/tmp/hook.log",
+				messagesPath: "/tmp/messages.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({
+				updated: true,
+				endedAt: "2026-01-01T00:00:05.000Z",
+			}),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		const run = vi.fn().mockResolvedValue(
+			createResult({
+				messages: [
+					{ role: "user", content: [{ type: "text", text: "hello" }] },
+				],
+			}),
+		);
+		const continueFn = vi.fn().mockResolvedValue(
+			createResult({
+				text: "steered",
+				messages: [
+					{ role: "user", content: [{ type: "text", text: "hello" }] },
+					{
+						role: "assistant",
+						content: [{ type: "text", text: "steered" }],
+					},
+				],
+			}),
+		);
+		const agent = {
+			run,
+			continue: continueFn,
+			abort: vi.fn(),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+			getMessages: vi
+				.fn()
+				.mockReturnValue([
+					{ role: "user", content: [{ type: "text", text: "hello" }] },
+				]),
+			canStartRun: vi.fn().mockReturnValue(true),
+		};
+
+		const manager = new DefaultSessionManager({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () => agent as never,
+		});
+
+		await manager.start({
+			config: createConfig({ sessionId }),
+			prompt: "hello",
+			interactive: true,
+		});
+
+		const harness = createPluginEventHarness(manager);
+		await harness.handlePluginEvent(sessionId, {
+			name: "steer_message",
+			payload: { prompt: "async result" },
+		});
+		await vi.waitFor(() => {
+			expect(continueFn).toHaveBeenCalledTimes(2);
+		});
+		expect(continueFn).toHaveBeenLastCalledWith(
+			'<user_input mode="act">async result</user_input>',
+			undefined,
+			undefined,
+		);
+	});
+
+	it("promotes queued prompts to the front when they become steer", async () => {
+		const sessionId = "sess-steer-priority";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest.json",
+				transcriptPath: "/tmp/transcript.log",
+				hookPath: "/tmp/hook.log",
+				messagesPath: "/tmp/messages.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({
+				updated: true,
+				endedAt: "2026-01-01T00:00:05.000Z",
+			}),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		const agent = {
+			run: vi.fn().mockResolvedValue(createResult()),
+			continue: vi.fn().mockResolvedValue(createResult()),
+			abort: vi.fn(),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+			getMessages: vi.fn().mockReturnValue([]),
+			canStartRun: vi.fn().mockReturnValue(false),
+		};
+
+		const manager = new DefaultSessionManager({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () => agent as never,
+		});
+
+		await manager.start({
+			config: createConfig({ sessionId }),
+			prompt: "hello",
+			interactive: true,
+		});
+
+		const harness = createPluginEventHarness(manager);
+
+		await harness.handlePluginEvent(sessionId, {
+			name: "queue_message",
+			payload: { prompt: "queued first" },
+		});
+		await harness.handlePluginEvent(sessionId, {
+			name: "queue_message",
+			payload: { prompt: "queued second" },
+		});
+		await harness.handlePluginEvent(sessionId, {
+			name: "steer_message",
+			payload: { prompt: "queued first" },
+		});
+
+		expect(harness.getPendingPrompts(sessionId)).toEqual([
+			{ prompt: "queued first", delivery: "steer" },
+			{ prompt: "queued second", delivery: "queue" },
+		]);
+	});
+
+	it("preserves per-turn metadata on prior assistant messages across turns", async () => {
+		const sessionId = "sess-meta-multi";
+		const manifest = createManifest(sessionId);
+		const persistSessionMessages = vi.fn();
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		const firstTurnMessages = [
+			{
+				role: "user" as const,
+				content: [{ type: "text" as const, text: "hello" }],
+			},
+			{
+				role: "assistant" as const,
+				content: [{ type: "text" as const, text: "world" }],
+			},
+		];
+		const secondTurnMessages = [
+			...firstTurnMessages,
+			{
+				role: "user" as const,
+				content: [{ type: "text" as const, text: "again" }],
+			},
+			{
+				role: "assistant" as const,
+				content: [{ type: "text" as const, text: "still here" }],
+			},
+		];
+		const run = vi.fn().mockResolvedValue(
+			createResult({
+				usage: {
+					inputTokens: 33,
+					outputTokens: 12,
+					cacheReadTokens: 4,
+					cacheWriteTokens: 1,
+					totalCost: 0.42,
+				},
+				model: {
+					id: "claude-sonnet-4-6",
+					provider: "anthropic",
+				},
+				endedAt: new Date("2026-01-01T00:00:02.000Z"),
+				messages: firstTurnMessages,
+			}),
+		);
+		const continueFn = vi.fn().mockResolvedValue(
+			createResult({
+				usage: {
+					inputTokens: 10,
+					outputTokens: 5,
+					cacheReadTokens: 2,
+					cacheWriteTokens: 0,
+					totalCost: 0.12,
+				},
+				model: {
+					id: "claude-sonnet-4-6",
+					provider: "anthropic",
+				},
+				endedAt: new Date("2026-01-01T00:00:03.000Z"),
+				messages: secondTurnMessages,
+			}),
+		);
+		const agent = {
+			run,
+			continue: continueFn,
+			abort: vi.fn(),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+			restore: vi.fn(),
+			getMessages: vi.fn().mockReturnValue([]),
+			messages: [],
+		};
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-meta-multi.json",
+				transcriptPath: "/tmp/transcript-meta-multi.log",
+				hookPath: "/tmp/hook-meta-multi.log",
+				messagesPath: "/tmp/messages-meta-multi.json",
+				manifest,
+			}),
+			persistSessionMessages,
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const manager = new DefaultSessionManager({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () => agent as never,
+		});
+
+		await manager.start({
+			config: createConfig({
+				sessionId,
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+			}),
+			interactive: true,
+		});
+
+		await manager.send({ sessionId, prompt: "hello" });
+		await manager.send({ sessionId, prompt: "again" });
+
+		const persisted = persistSessionMessages.mock.calls[1]?.[1];
+		expect(persisted?.[1]).toMatchObject({
+			role: "assistant",
+			metrics: {
+				inputTokens: 33,
+				outputTokens: 12,
+				cacheReadTokens: 4,
+				cacheWriteTokens: 1,
+				cost: 0.42,
+			},
+		});
+		expect(persisted?.[3]).toMatchObject({
+			role: "assistant",
+			metrics: {
+				inputTokens: 10,
+				outputTokens: 5,
+				cacheReadTokens: 2,
+				cacheWriteTokens: 0,
+				cost: 0.12,
+			},
+		});
+	});
+
 	it("persists rendered messages when a turn fails", async () => {
 		const sessionId = "sess-failed-turn";
 		const manifest = createManifest(sessionId);
@@ -522,6 +888,112 @@ describe("DefaultSessionManager", () => {
 		});
 	});
 
+	it("queues sends with explicit queue or steer delivery and emits snapshots", async () => {
+		const sessionId = "sess-delivery-queue";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-queue.json",
+				transcriptPath: "/tmp/transcript-queue.log",
+				hookPath: "/tmp/hook-queue.log",
+				messagesPath: "/tmp/messages-queue.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		let canStartRun = false;
+		const run = vi.fn().mockResolvedValue(createResult({ text: "first" }));
+		const continueFn = vi
+			.fn()
+			.mockResolvedValue(createResult({ text: "next" }));
+		const manager = new DefaultSessionManager({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run,
+					continue: continueFn,
+					canStartRun: vi.fn(() => canStartRun),
+					abort: vi.fn(),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+		const events: Array<unknown> = [];
+		manager.subscribe((event) => {
+			events.push(event);
+		});
+
+		await manager.start({
+			config: createConfig({ sessionId }),
+			interactive: true,
+		});
+
+		await expect(
+			manager.send({ sessionId, prompt: "queued first", delivery: "queue" }),
+		).resolves.toBeUndefined();
+		await expect(
+			manager.send({ sessionId, prompt: "queued second", delivery: "steer" }),
+		).resolves.toBeUndefined();
+
+		expect(run).not.toHaveBeenCalled();
+		expect(continueFn).not.toHaveBeenCalled();
+		const promptSnapshots = events
+			.filter((event) => {
+				return (
+					typeof event === "object" &&
+					event !== null &&
+					"type" in event &&
+					event.type === "pending_prompts"
+				);
+			})
+			.map((event) => (event as { payload: { prompts: unknown[] } }).payload);
+		expect(promptSnapshots.at(-1)).toEqual({
+			prompts: [
+				expect.objectContaining({
+					prompt: "queued second",
+					delivery: "steer",
+					attachmentCount: 0,
+				}),
+				expect.objectContaining({
+					prompt: "queued first",
+					delivery: "queue",
+					attachmentCount: 0,
+				}),
+			],
+			sessionId,
+		});
+
+		canStartRun = true;
+		await manager.send({ sessionId, prompt: "run now" });
+		expect(run).toHaveBeenCalledTimes(1);
+		expect(
+			events.some((event) => {
+				return (
+					typeof event === "object" &&
+					event !== null &&
+					"type" in event &&
+					event.type === "pending_prompt_submitted" &&
+					"payload" in event &&
+					(event.payload as { prompt?: string }).prompt === "queued second"
+				);
+			}),
+		).toBe(true);
+	});
+
 	it("returns undefined accumulated usage for unknown sessions", async () => {
 		const manager = new DefaultSessionManager({
 			distinctId,
@@ -1155,4 +1627,115 @@ describe("DefaultSessionManager", () => {
 			failedMessages,
 		);
 	});
+
+	it("persists teammate progress updates for team-task sub-sessions", async () => {
+		const sessionId = "sess-team-task-progress";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-team-task-progress.json",
+				transcriptPath: "/tmp/transcript-team-task-progress.log",
+				hookPath: "/tmp/hook-team-task-progress.log",
+				messagesPath: "/tmp/messages-team-task-progress.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+			onTeamTaskStart: vi.fn().mockResolvedValue(undefined),
+			onTeamTaskEnd: vi.fn().mockResolvedValue(undefined),
+			onTeamTaskProgress: vi.fn().mockResolvedValue(undefined),
+		};
+
+		let onTeamEvent: ((event: unknown) => void) | undefined;
+		const runtimeBuilder = {
+			build: vi
+				.fn()
+				.mockImplementation(
+					(input: { onTeamEvent?: (event: unknown) => void }) => {
+						onTeamEvent = input.onTeamEvent;
+						return {
+							tools: [],
+							shutdown: vi.fn(),
+						};
+					},
+				),
+		};
+
+		const manager = new DefaultSessionManager({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run: vi.fn().mockImplementation(async () => {
+						onTeamEvent?.({
+							type: "task_start",
+							agentId: "providers-investigator",
+							message: "Investigate provider boundaries",
+						});
+						onTeamEvent?.({
+							type: "run_progress",
+							run: {
+								id: "run_00002",
+								agentId: "providers-investigator",
+								status: "running",
+								message: "Investigate provider boundaries",
+								priority: 0,
+								retryCount: 0,
+								maxRetries: 0,
+								continueConversation: false,
+								startedAt: new Date("2026-01-01T00:00:00.000Z"),
+								lastProgressAt: new Date("2026-01-01T00:00:01.000Z"),
+								lastProgressMessage: "heartbeat",
+								currentActivity: "heartbeat",
+							},
+							message: "heartbeat",
+						});
+						onTeamEvent?.({
+							type: "agent_event",
+							agentId: "providers-investigator",
+							event: {
+								type: "content_start",
+								contentType: "text",
+								text: "Drafting the provider boundary analysis now.",
+							},
+						});
+						onTeamEvent?.({
+							type: "task_end",
+							agentId: "providers-investigator",
+							result: createResult(),
+						});
+						return createResult({ text: "lead handled progress" });
+					}),
+					continue: vi.fn(),
+					abort: vi.fn(),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		await manager.start({
+			config: createConfig({ sessionId }),
+			prompt: "run teammate work",
+			interactive: false,
+		});
+
+		expect(sessionService.onTeamTaskProgress).toHaveBeenCalledWith(
+			sessionId,
+			"providers-investigator",
+			"heartbeat",
+			{ kind: "heartbeat" },
+		);
+		expect(sessionService.onTeamTaskProgress).toHaveBeenCalledWith(
+			sessionId,
+			"providers-investigator",
+			"Drafting the provider boundary analysis now.",
+			{ kind: "text" },
+		);
+	});
 });