@clinebot/core 0.0.11 → 0.0.13

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

@@ -64,7 +64,7 @@ import { SessionManifestSchema } from "./session-manifest";
 import type {
 	CoreSessionService,
 	RootSessionArtifacts,
-	SessionRowShape,
+	SessionRow,
 } from "./session-service";
 import {
 	buildTeamRunContinuationPrompt,
@@ -223,6 +223,7 @@ export class DefaultSessionManager implements SessionManager {
 				hookPath,
 				sessionId,
 				this.defaultTelemetry,
+				(e) => void this.handlePluginEvent(sessionId, e),
 			);
 		const providerConfig = buildResolvedProviderConfig(
 			effectiveConfig,
@@ -307,6 +308,8 @@ export class DefaultSessionManager implements SessionManager {
 			activeTeamRunIds: new Set<string>(),
 			pendingTeamRunUpdates: [],
 			teamRunWaiters: [],
+			pendingPrompts: [],
+			drainingPendingPrompts: false,
 			pluginSandboxShutdown,
 		};
 		this.sessions.set(sessionId, active);
@@ -349,8 +352,18 @@ export class DefaultSessionManager implements SessionManager {
 				promptLength: input.prompt.length,
 				userImageCount: input.userImages?.length ?? 0,
 				userFileCount: input.userFiles?.length ?? 0,
+				delivery: input.delivery ?? "immediate",
 			},
 		});
+		if (input.delivery === "queue" || input.delivery === "steer") {
+			this.enqueuePendingPrompt(input.sessionId, {
+				prompt: input.prompt,
+				delivery: input.delivery,
+				userImages: input.userImages,
+				userFiles: input.userFiles,
+			});
+			return undefined;
+		}
 		try {
 			const result = await this.runTurn(session, {
 				prompt: input.prompt,
@@ -360,6 +373,9 @@ export class DefaultSessionManager implements SessionManager {
 			if (!session.interactive) {
 				await this.finalizeSingleRun(session, result.finishReason);
 			}
+			queueMicrotask(() => {
+				void this.drainPendingPrompts(input.sessionId);
+			});
 			return result;
 		} catch (error) {
 			await this.failSession(session);
@@ -446,8 +462,8 @@ export class DefaultSessionManager implements SessionManager {
 
 	async readTranscript(sessionId: string, maxChars?: number): Promise<string> {
 		const row = await this.getRow(sessionId);
-		if (!row?.transcript_path || !existsSync(row.transcript_path)) return "";
-		const raw = readFileSync(row.transcript_path, "utf8");
+		if (!row?.transcriptPath || !existsSync(row.transcriptPath)) return "";
+		const raw = readFileSync(row.transcriptPath, "utf8");
 		if (typeof maxChars === "number" && Number.isFinite(maxChars)) {
 			return raw.slice(-Math.max(0, Math.floor(maxChars)));
 		}
@@ -456,7 +472,7 @@ export class DefaultSessionManager implements SessionManager {
 
 	async readMessages(sessionId: string): Promise<LlmsProviders.Message[]> {
 		const row = await this.getRow(sessionId);
-		const messagesPath = row?.messages_path?.trim();
+		const messagesPath = row?.messagesPath?.trim();
 		if (!messagesPath || !existsSync(messagesPath)) return [];
 		try {
 			const raw = readFileSync(messagesPath, "utf8").trim();
@@ -475,8 +491,8 @@ export class DefaultSessionManager implements SessionManager {
 
 	async readHooks(sessionId: string, limit = 200): Promise<unknown[]> {
 		const row = await this.getRow(sessionId);
-		if (!row?.hook_path || !existsSync(row.hook_path)) return [];
-		const lines = readFileSync(row.hook_path, "utf8")
+		if (!row?.hookPath || !existsSync(row.hookPath)) return [];
+		const lines = readFileSync(row.hookPath, "utf8")
 			.split("\n")
 			.filter((line) => line.trim().length > 0);
 		return lines.slice(-Math.max(1, Math.floor(limit))).map((line) => {
@@ -766,6 +782,151 @@ export class DefaultSessionManager implements SessionManager {
 		this.emitStatus(session.sessionId, status);
 	}
 
+	private async handlePluginEvent(
+		rootSessionId: string,
+		event: { name: string; payload?: unknown },
+	): Promise<void> {
+		if (
+			event.name !== "steer_message" &&
+			event.name !== "queue_message" &&
+			event.name !== "pending_prompt"
+		) {
+			return;
+		}
+		const payload =
+			event.payload && typeof event.payload === "object"
+				? (event.payload as Record<string, unknown>)
+				: undefined;
+		const targetSessionId =
+			typeof payload?.sessionId === "string" &&
+			payload.sessionId.trim().length > 0
+				? payload.sessionId.trim()
+				: rootSessionId;
+		const prompt =
+			typeof payload?.prompt === "string" ? payload.prompt.trim() : "";
+		if (!prompt) {
+			return;
+		}
+		const delivery =
+			event.name === "steer_message"
+				? "steer"
+				: event.name === "queue_message"
+					? "queue"
+					: payload?.delivery === "steer"
+						? "steer"
+						: "queue";
+		this.enqueuePendingPrompt(targetSessionId, {
+			prompt,
+			delivery,
+		});
+	}
+
+	private enqueuePendingPrompt(
+		sessionId: string,
+		entry: {
+			prompt: string;
+			delivery: "queue" | "steer";
+			userImages?: string[];
+			userFiles?: string[];
+		},
+	): void {
+		const session = this.sessions.get(sessionId);
+		if (!session) {
+			return;
+		}
+		const { prompt, delivery, userImages, userFiles } = entry;
+		const existingIndex = session.pendingPrompts.findIndex(
+			(queued) => queued.prompt === prompt,
+		);
+		if (existingIndex >= 0) {
+			const [existing] = session.pendingPrompts.splice(existingIndex, 1);
+			if (delivery === "steer" || existing.delivery === "steer") {
+				session.pendingPrompts.unshift({
+					id: existing.id,
+					prompt,
+					delivery: "steer",
+					userImages: userImages ?? existing.userImages,
+					userFiles: userFiles ?? existing.userFiles,
+				});
+			} else {
+				session.pendingPrompts.push({
+					...existing,
+					userImages: userImages ?? existing.userImages,
+					userFiles: userFiles ?? existing.userFiles,
+				});
+			}
+		} else if (delivery === "steer") {
+			session.pendingPrompts.unshift({
+				id: `pending_${Date.now()}_${nanoid(5)}`,
+				prompt,
+				delivery,
+				userImages,
+				userFiles,
+			});
+		} else {
+			session.pendingPrompts.push({
+				id: `pending_${Date.now()}_${nanoid(5)}`,
+				prompt,
+				delivery,
+				userImages,
+				userFiles,
+			});
+		}
+		this.emitPendingPrompts(session);
+		queueMicrotask(() => {
+			void this.drainPendingPrompts(sessionId);
+		});
+	}
+
+	private async drainPendingPrompts(sessionId: string): Promise<void> {
+		const session = this.sessions.get(sessionId);
+		if (!session || session.drainingPendingPrompts) {
+			return;
+		}
+		const canStartRun =
+			typeof (session.agent as Agent & { canStartRun?: () => boolean })
+				.canStartRun === "function"
+				? (
+						session.agent as Agent & {
+							canStartRun: () => boolean;
+						}
+					).canStartRun()
+				: true;
+		if (!canStartRun) {
+			return;
+		}
+		const next = session.pendingPrompts.shift();
+		if (!next) {
+			return;
+		}
+		this.emitPendingPrompts(session);
+		this.emitPendingPromptSubmitted(session, next);
+		session.drainingPendingPrompts = true;
+		try {
+			await this.send({
+				sessionId,
+				prompt: next.prompt,
+				userImages: next.userImages,
+				userFiles: next.userFiles,
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			if (message.includes("already in progress")) {
+				session.pendingPrompts.unshift(next);
+				this.emitPendingPrompts(session);
+			} else {
+				throw error;
+			}
+		} finally {
+			session.drainingPendingPrompts = false;
+			if (session.pendingPrompts.length > 0) {
+				queueMicrotask(() => {
+					void this.drainPendingPrompts(sessionId);
+				});
+			}
+		}
+	}
+
 	// ── Agent event handling ────────────────────────────────────────────
 
 	private onAgentEvent(
@@ -791,6 +952,45 @@ export class DefaultSessionManager implements SessionManager {
 		handleAgentEvent(ctx, event);
 	}
 
+	private emitPendingPrompts(session: ActiveSession): void {
+		this.emit({
+			type: "pending_prompts",
+			payload: {
+				sessionId: session.sessionId,
+				prompts: session.pendingPrompts.map((entry) => ({
+					id: entry.id,
+					prompt: entry.prompt,
+					delivery: entry.delivery,
+					attachmentCount:
+						(entry.userImages?.length ?? 0) + (entry.userFiles?.length ?? 0),
+				})),
+			},
+		});
+	}
+
+	private emitPendingPromptSubmitted(
+		session: ActiveSession,
+		entry: {
+			id: string;
+			prompt: string;
+			delivery: "queue" | "steer";
+			userImages?: string[];
+			userFiles?: string[];
+		},
+	): void {
+		this.emit({
+			type: "pending_prompt_submitted",
+			payload: {
+				sessionId: session.sessionId,
+				id: entry.id,
+				prompt: entry.prompt,
+				delivery: entry.delivery,
+				attachmentCount:
+					(entry.userImages?.length ?? 0) + (entry.userFiles?.length ?? 0),
+			},
+		});
+	}
+
 	// ── Spawn / sub-agents ──────────────────────────────────────────────
 
 	private createSpawnTool(
@@ -964,20 +1164,18 @@ export class DefaultSessionManager implements SessionManager {
 		for (const listener of this.listeners) listener(event);
 	}
 
-	private async listRows(limit: number): Promise<SessionRowShape[]> {
-		return this.invoke<SessionRowShape[]>(
+	private async listRows(limit: number): Promise<SessionRow[]> {
+		return this.invoke<SessionRow[]>(
 			"listSessions",
 			Math.min(Math.max(1, Math.floor(limit)), MAX_SCAN_LIMIT),
 		);
 	}
 
-	private async getRow(
-		sessionId: string,
-	): Promise<SessionRowShape | undefined> {
+	private async getRow(sessionId: string): Promise<SessionRow | undefined> {
 		const target = sessionId.trim();
 		if (!target) return undefined;
 		const rows = await this.listRows(MAX_SCAN_LIMIT);
-		return rows.find((row) => row.session_id === target);
+		return rows.find((row) => row.sessionId === target);
 	}
 
 	// ── Session service invocation ──────────────────────────────────────

package/src/session/rpc-session-service.ts

@@ -1,91 +1,13 @@
 import { existsSync, mkdirSync } from "node:fs";
 import { RpcSessionClient, type RpcSessionRow } from "@clinebot/rpc";
-import { nowIso } from "./session-artifacts";
-import type { SessionRowShape } from "./session-service";
+import type { SessionRow } from "./session-service";
 import type {
 	PersistedSessionUpdateInput,
 	SessionPersistenceAdapter,
 } from "./unified-session-persistence-service";
 import { UnifiedSessionPersistenceService } from "./unified-session-persistence-service";
 
-function toShape(row: RpcSessionRow): SessionRowShape {
-	return {
-		session_id: row.sessionId,
-		source: row.source,
-		pid: row.pid,
-		started_at: row.startedAt,
-		ended_at: row.endedAt ?? null,
-		exit_code: row.exitCode ?? null,
-		status: row.status,
-		status_lock: row.statusLock,
-		interactive: row.interactive ? 1 : 0,
-		provider: row.provider,
-		model: row.model,
-		cwd: row.cwd,
-		workspace_root: row.workspaceRoot,
-		team_name: row.teamName ?? null,
-		enable_tools: row.enableTools ? 1 : 0,
-		enable_spawn: row.enableSpawn ? 1 : 0,
-		enable_teams: row.enableTeams ? 1 : 0,
-		parent_session_id: row.parentSessionId ?? null,
-		parent_agent_id: row.parentAgentId ?? null,
-		agent_id: row.agentId ?? null,
-		conversation_id: row.conversationId ?? null,
-		is_subagent: row.isSubagent ? 1 : 0,
-		prompt: row.prompt ?? null,
-		metadata_json: row.metadata ? JSON.stringify(row.metadata) : null,
-		transcript_path: row.transcriptPath,
-		hook_path: row.hookPath,
-		messages_path: row.messagesPath ?? null,
-		updated_at: row.updatedAt,
-	};
-}
-
-function fromShape(row: SessionRowShape): RpcSessionRow {
-	return {
-		sessionId: row.session_id,
-		source: row.source,
-		pid: row.pid,
-		startedAt: row.started_at,
-		endedAt: row.ended_at ?? null,
-		exitCode: row.exit_code ?? null,
-		status: row.status,
-		statusLock: row.status_lock ?? 0,
-		interactive: row.interactive === 1,
-		provider: row.provider,
-		model: row.model,
-		cwd: row.cwd,
-		workspaceRoot: row.workspace_root,
-		teamName: row.team_name ?? undefined,
-		enableTools: row.enable_tools === 1,
-		enableSpawn: row.enable_spawn === 1,
-		enableTeams: row.enable_teams === 1,
-		parentSessionId: row.parent_session_id ?? undefined,
-		parentAgentId: row.parent_agent_id ?? undefined,
-		agentId: row.agent_id ?? undefined,
-		conversationId: row.conversation_id ?? undefined,
-		isSubagent: row.is_subagent === 1,
-		prompt: row.prompt ?? undefined,
-		metadata: (() => {
-			if (!row.metadata_json) {
-				return undefined;
-			}
-			try {
-				const parsed = JSON.parse(row.metadata_json) as unknown;
-				if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-					return parsed as Record<string, unknown>;
-				}
-			} catch {
-				// Ignore malformed metadata payloads.
-			}
-			return undefined;
-		})(),
-		transcriptPath: row.transcript_path,
-		hookPath: row.hook_path,
-		messagesPath: row.messages_path ?? undefined,
-		updatedAt: row.updated_at ?? nowIso(),
-	};
-}
+// ── Adapter ──────────────────────────────────────────────────────────
 
 class RpcSessionPersistenceAdapter implements SessionPersistenceAdapter {
 	constructor(private readonly client: RpcSessionClient) {}
@@ -94,39 +16,34 @@ class RpcSessionPersistenceAdapter implements SessionPersistenceAdapter {
 		return "";
 	}
 
-	async upsertSession(row: SessionRowShape): Promise<void> {
-		await this.client.upsertSession(fromShape(row));
+	async upsertSession(row: SessionRow): Promise<void> {
+		await this.client.upsertSession(row as RpcSessionRow);
 	}
 
-	async getSession(sessionId: string): Promise<SessionRowShape | undefined> {
+	async getSession(sessionId: string): Promise<SessionRow | undefined> {
 		const row = await this.client.getSession(sessionId);
-		return row ? toShape(row) : undefined;
+		return (row as SessionRow | undefined) ?? undefined;
 	}
 
 	async listSessions(options: {
 		limit: number;
 		parentSessionId?: string;
 		status?: string;
-	}): Promise<SessionRowShape[]> {
+	}): Promise<SessionRow[]> {
 		const rows = await this.client.listSessions(options);
-		return rows.map((row) => toShape(row));
+		return rows as SessionRow[];
 	}
 
 	async updateSession(
 		input: PersistedSessionUpdateInput,
 	): Promise<{ updated: boolean; statusLock: number }> {
-		const changed = await this.client.updateSession({
+		return this.client.updateSession({
 			sessionId: input.sessionId,
 			status: input.status,
 			endedAt: input.endedAt,
 			exitCode: input.exitCode,
 			prompt: input.prompt,
-			metadata:
-				input.metadataJson === undefined
-					? undefined
-					: input.metadataJson
-						? (JSON.parse(input.metadataJson) as Record<string, unknown>)
-						: null,
+			metadata: input.metadata,
 			parentSessionId: input.parentSessionId,
 			parentAgentId: input.parentAgentId,
 			agentId: input.agentId,
@@ -134,11 +51,10 @@ class RpcSessionPersistenceAdapter implements SessionPersistenceAdapter {
 			expectedStatusLock: input.expectedStatusLock,
 			setRunning: input.setRunning,
 		});
-		return changed;
 	}
 
 	async deleteSession(sessionId: string, cascade: boolean): Promise<boolean> {
-		return await this.client.deleteSession(sessionId, cascade);
+		return this.client.deleteSession(sessionId, cascade);
 	}
 
 	async enqueueSpawnRequest(input: {
@@ -154,10 +70,12 @@ class RpcSessionPersistenceAdapter implements SessionPersistenceAdapter {
 		rootSessionId: string,
 		parentAgentId: string,
 	): Promise<string | undefined> {
-		return await this.client.claimSpawnRequest(rootSessionId, parentAgentId);
+		return this.client.claimSpawnRequest(rootSessionId, parentAgentId);
 	}
 }
 
+// ── Service ──────────────────────────────────────────────────────────
+
 export interface RpcCoreSessionServiceOptions {
 	address?: string;
 	sessionsDir: string;

package/src/session/session-config-builder.ts

@@ -24,6 +24,7 @@ export async function buildEffectiveConfig(
 	hookPath: string,
 	sessionId: string,
 	defaultTelemetry: ITelemetryService | undefined,
+	onPluginEvent?: (event: { name: string; payload?: unknown }) => void,
 ): Promise<{
 	config: CoreSessionConfig;
 	pluginSandboxShutdown?: () => Promise<void>;
@@ -54,6 +55,7 @@ export async function buildEffectiveConfig(
 		pluginPaths: input.config.pluginPaths,
 		workspacePath,
 		cwd: input.config.cwd,
+		onEvent: onPluginEvent,
 	});
 	const effectiveExtensions = mergeAgentExtensions(
 		input.config.extensions,

package/src/session/session-manager.ts

@@ -38,6 +38,7 @@ export interface SendSessionInput {
 	prompt: string;
 	userImages?: string[];
 	userFiles?: string[];
+	delivery?: "queue" | "steer";
 }
 
 export interface SessionAccumulatedUsage {