@clinebot/core 0.0.11 → 0.0.13

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

@@ -11,12 +11,13 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { AgentResult } from "@clinebot/agents";
 import type { LlmsProviders } from "@clinebot/llms";
+import { setClineDir, setHomeDir } from "@clinebot/shared/storage";
 import { nanoid } from "nanoid";
-import { afterEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import type { SessionSource, SessionStatus } from "../types/common";
 import { DefaultSessionManager } from "./default-session-manager";
 import type { SessionManifest } from "./session-manifest";
-import type { RootSessionArtifacts, SessionRowShape } from "./session-service";
+import type { RootSessionArtifacts, SessionRow } from "./session-service";
 
 function nowIso(): string {
 	return new Date().toISOString();
@@ -46,7 +47,7 @@ function createResult(overrides: Partial<AgentResult> = {}): AgentResult {
 }
 
 class LocalFileSessionService {
-	private readonly rows = new Map<string, SessionRowShape>();
+	private readonly rows = new Map<string, SessionRow>();
 
 	constructor(private readonly sessionsDir: string) {}
 
@@ -114,33 +115,33 @@ class LocalFileSessionService {
 		);
 
 		this.rows.set(sessionId, {
-			session_id: sessionId,
+			sessionId,
 			source: input.source,
 			pid: input.pid,
-			started_at: startedAt,
-			ended_at: null,
-			exit_code: null,
+			startedAt,
+			endedAt: null,
+			exitCode: null,
 			status: "running",
-			status_lock: 0,
-			interactive: input.interactive ? 1 : 0,
+			statusLock: 0,
+			interactive: input.interactive,
 			provider: input.provider,
 			model: input.model,
 			cwd: input.cwd,
-			workspace_root: input.workspaceRoot,
-			team_name: input.teamName ?? null,
-			enable_tools: input.enableTools ? 1 : 0,
-			enable_spawn: input.enableSpawn ? 1 : 0,
-			enable_teams: input.enableTeams ? 1 : 0,
-			parent_session_id: null,
-			parent_agent_id: null,
-			agent_id: null,
-			conversation_id: null,
-			is_subagent: 0,
+			workspaceRoot: input.workspaceRoot,
+			teamName: input.teamName ?? null,
+			enableTools: input.enableTools,
+			enableSpawn: input.enableSpawn,
+			enableTeams: input.enableTeams,
+			parentSessionId: null,
+			parentAgentId: null,
+			agentId: null,
+			conversationId: null,
+			isSubagent: false,
 			prompt: prompt ?? null,
-			transcript_path: transcriptPath,
-			hook_path: hookPath,
-			messages_path: messagesPath,
-			updated_at: startedAt,
+			transcriptPath,
+			hookPath,
+			messagesPath,
+			updatedAt: startedAt,
 		});
 
 		return {
@@ -158,7 +159,7 @@ class LocalFileSessionService {
 		systemPrompt?: string,
 	): void {
 		const row = this.rows.get(sessionId);
-		if (!row?.messages_path) {
+		if (!row?.messagesPath) {
 			throw new Error(`session not found: ${sessionId}`);
 		}
 		const payload: {
@@ -171,7 +172,7 @@ class LocalFileSessionService {
 			payload.systemPrompt = systemPrompt;
 		}
 		writeFileSync(
-			row.messages_path,
+			row.messagesPath,
 			`${JSON.stringify(payload, null, 2)}\n`,
 			"utf8",
 		);
@@ -188,10 +189,10 @@ class LocalFileSessionService {
 		}
 		const endedAt = nowIso();
 		row.status = status;
-		row.ended_at = endedAt;
-		row.exit_code = typeof exitCode === "number" ? exitCode : null;
-		row.updated_at = endedAt;
-		row.status_lock = (row.status_lock ?? 0) + 1;
+		row.endedAt = endedAt;
+		row.exitCode = typeof exitCode === "number" ? exitCode : null;
+		row.updatedAt = endedAt;
+		row.statusLock = row.statusLock + 1;
 		return { updated: true, endedAt };
 	}
 
@@ -203,7 +204,7 @@ class LocalFileSessionService {
 		);
 	}
 
-	listSessions(limit = 200): SessionRowShape[] {
+	listSessions(limit = 200): SessionRow[] {
 		return Array.from(this.rows.values()).slice(0, limit);
 	}
 
@@ -213,21 +214,39 @@ class LocalFileSessionService {
 			return { deleted: false };
 		}
 		this.rows.delete(sessionId);
-		unlinkSync(row.transcript_path);
-		unlinkSync(row.hook_path);
-		unlinkSync(row.messages_path ?? "");
+		unlinkSync(row.transcriptPath);
+		unlinkSync(row.hookPath);
+		unlinkSync(row.messagesPath ?? "");
 		unlinkSync(join(this.sessionsDir, sessionId, `${sessionId}.json`));
 		return { deleted: true };
 	}
 }
 
 describe("DefaultSessionManager e2e", () => {
+	const envSnapshot = {
+		HOME: process.env.HOME,
+		CLINE_DIR: process.env.CLINE_DIR,
+	};
 	const tempDirs: string[] = [];
+	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"));
 		for (const dir of tempDirs.splice(0)) {
 			rmSync(dir, { recursive: true, force: true });
 		}
+		rmSync(isolatedHomeDir, { recursive: true, force: true });
 	});
 
 	it("runs an interactive lifecycle with real artifact files", async () => {

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,163 @@ 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);
@@ -653,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,
@@ -1286,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" },
+		);
+	});
 });