@clinebot/core 0.0.34 → 0.0.35

package/src/runtime/history.ts

@@ -0,0 +1,237 @@
+import type * as LlmsProviders from "@clinebot/llms";
+import { formatDisplayUserInput, normalizeUserInput } from "@clinebot/shared";
+import type {
+	SessionHistoryMetadata,
+	SessionHistoryRecord,
+	SessionRecord,
+} from "../types/sessions";
+import type { RuntimeHost } from "./runtime-host";
+
+type StoredSessionMessage = LlmsProviders.Message & {
+	metrics?: {
+		cost?: number;
+	};
+	modelInfo?: {
+		id?: string;
+		provider?: string;
+	};
+};
+
+type TextBlock = {
+	type?: string;
+	text?: string;
+};
+
+function asTrimmedString(value: unknown): string | undefined {
+	if (typeof value !== "string") {
+		return undefined;
+	}
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function asKnownString(value: unknown): string | undefined {
+	const trimmed = asTrimmedString(value);
+	if (!trimmed) {
+		return undefined;
+	}
+	return trimmed.toLowerCase() === "unknown" ? undefined : trimmed;
+}
+
+function asFiniteNumber(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value)
+		? value
+		: undefined;
+}
+
+function asHistoryMetadata(value: unknown): SessionHistoryMetadata | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return undefined;
+	}
+	return { ...(value as Record<string, unknown>) };
+}
+
+function extractTextFromContent(
+	content: LlmsProviders.Message["content"],
+): string {
+	if (typeof content === "string") {
+		return content.trim();
+	}
+	const segments: string[] = [];
+	for (const block of content) {
+		if (!block || typeof block !== "object") {
+			continue;
+		}
+		const maybeText = block as TextBlock;
+		if (maybeText.type !== "text") {
+			continue;
+		}
+		const text = maybeText.text?.trim();
+		if (text) {
+			segments.push(text);
+		}
+	}
+	return segments.join("\n").trim();
+}
+
+function toSingleLine(text: string): string {
+	return text.replace(/\s+/g, " ").trim();
+}
+
+function truncateText(text: string, limit: number): string {
+	if (text.length <= limit) {
+		return text;
+	}
+	return `${text.slice(0, Math.max(0, limit - 3)).trimEnd()}...`;
+}
+
+function inferTitleFromMessages(
+	messages: LlmsProviders.Message[],
+): string | undefined {
+	for (const role of ["user", "assistant"] as const) {
+		for (const raw of messages) {
+			if (raw.role !== role) {
+				continue;
+			}
+			const text = toSingleLine(extractTextFromContent(raw.content));
+			if (!text) {
+				continue;
+			}
+			const formatted =
+				role === "user" ? toSingleLine(formatDisplayUserInput(text)) : text;
+			const normalized = normalizeUserInput(
+				formatted.split("\n")[0] ?? formatted,
+			);
+			return truncateText(normalized, 50);
+		}
+	}
+	return undefined;
+}
+
+function summarizeCostFromMessages(messages: LlmsProviders.Message[]): number {
+	let total = 0;
+	for (const message of messages as StoredSessionMessage[]) {
+		total += asFiniteNumber(message.metrics?.cost) ?? 0;
+	}
+	return total;
+}
+
+function inferProviderAndModelFromMessages(messages: LlmsProviders.Message[]): {
+	provider?: string;
+	model?: string;
+} {
+	let provider: string | undefined;
+	let model: string | undefined;
+	for (let i = messages.length - 1; i >= 0; i -= 1) {
+		const message = messages[i] as StoredSessionMessage;
+		if (!provider) {
+			provider = asKnownString(message.modelInfo?.provider);
+		}
+		if (!model) {
+			model = asKnownString(message.modelInfo?.id);
+		}
+		if (provider && model) {
+			break;
+		}
+	}
+	return { provider, model };
+}
+
+function getMetadataProvider(
+	metadata?: SessionHistoryMetadata,
+): string | undefined {
+	return (
+		asKnownString(metadata?.provider) ??
+		asKnownString(
+			metadata?.provider &&
+				typeof metadata.provider === "object" &&
+				!Array.isArray(metadata.provider)
+				? (metadata.provider as Record<string, unknown>).id
+				: undefined,
+		)
+	);
+}
+
+function getMetadataModel(
+	metadata?: SessionHistoryMetadata,
+): string | undefined {
+	return (
+		asKnownString(metadata?.model) ??
+		asKnownString(
+			metadata?.model &&
+				typeof metadata.model === "object" &&
+				!Array.isArray(metadata.model)
+				? (metadata.model as Record<string, unknown>).id
+				: undefined,
+		)
+	);
+}
+
+function normalizeHistoryRow(
+	row: SessionRecord,
+	overrides?: {
+		title?: string;
+		provider?: string;
+		model?: string;
+		totalCost?: number;
+	},
+): SessionHistoryRecord {
+	const metadata = asHistoryMetadata(row.metadata);
+	const title =
+		asTrimmedString(overrides?.title) ?? asTrimmedString(metadata?.title);
+	const totalCost =
+		asFiniteNumber(overrides?.totalCost) ?? asFiniteNumber(metadata?.totalCost);
+	const nextMetadata =
+		metadata || title !== undefined || totalCost !== undefined
+			? {
+					...(metadata ?? {}),
+					...(title !== undefined ? { title } : {}),
+					...(totalCost !== undefined ? { totalCost } : {}),
+				}
+			: undefined;
+	return {
+		...row,
+		provider:
+			asKnownString(overrides?.provider) ??
+			asKnownString(row.provider) ??
+			getMetadataProvider(metadata) ??
+			"",
+		model:
+			asKnownString(overrides?.model) ??
+			asKnownString(row.model) ??
+			getMetadataModel(metadata) ??
+			"",
+		metadata: nextMetadata,
+	};
+}
+
+export async function hydrateSessionHistory(
+	host: Pick<RuntimeHost, "readMessages">,
+	rows: SessionRecord[],
+): Promise<SessionHistoryRecord[]> {
+	return await Promise.all(
+		rows.map(async (row) => {
+			const initial = normalizeHistoryRow(row);
+			const hasTitle = Boolean(asTrimmedString(initial.metadata?.title));
+			const hasProvider = Boolean(asKnownString(initial.provider));
+			const hasModel = Boolean(asKnownString(initial.model));
+			const knownCost = asFiniteNumber(initial.metadata?.totalCost);
+			const hasCost = knownCost !== undefined && knownCost > 0;
+			if (hasTitle && hasProvider && hasModel && hasCost) {
+				return initial;
+			}
+			const messages = await host.readMessages(row.sessionId);
+			if (messages.length === 0) {
+				return initial;
+			}
+			const inferredProviderModel = inferProviderAndModelFromMessages(messages);
+			const inferredCost = summarizeCostFromMessages(messages);
+			return normalizeHistoryRow(row, {
+				title: hasTitle ? undefined : inferTitleFromMessages(messages),
+				provider: hasProvider ? undefined : inferredProviderModel.provider,
+				model: hasModel ? undefined : inferredProviderModel.model,
+				totalCost: hasCost || inferredCost <= 0 ? undefined : inferredCost,
+			});
+		}),
+	);
+}

package/src/runtime/host.test.ts

@@ -0,0 +1,230 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { FileSessionService } from "../session/file-session-service";
+
+const sqliteInitMock = vi.hoisted(() => vi.fn());
+const ensureRpcRuntimeAddressMock = vi.hoisted(() => vi.fn());
+const resolveRpcOwnerContextMock = vi.hoisted(() =>
+	vi.fn(() => ({
+		ownerId: "core-owner",
+		buildId: "core-build",
+		discoveryPath: "/tmp/rpc-owner.json",
+	})),
+);
+const rpcHealthByAddress = vi.hoisted(() => new Map<string, unknown>());
+
+vi.mock("@clinebot/rpc", () => ({
+	RPC_BUILD_VERSION: "rpc-build-test",
+	getRpcServerDefaultAddress: () => "ws://127.0.0.1:0",
+	getRpcServerHealth: vi.fn(async (address: string) => {
+		return rpcHealthByAddress.get(address);
+	}),
+}));
+
+vi.mock("./rpc-runtime-ensure", () => ({
+	ensureRpcRuntimeAddress: ensureRpcRuntimeAddressMock,
+	resolveRpcOwnerContext: resolveRpcOwnerContextMock,
+}));
+
+vi.mock("../services/storage/sqlite-session-store", () => ({
+	SqliteSessionStore: class {
+		init(): void {
+			sqliteInitMock();
+		}
+	},
+}));
+
+describe("runtime host resolution", () => {
+	const logger = {
+		debug: vi.fn(),
+		log: vi.fn(),
+		error: vi.fn(),
+	};
+
+	afterEach(() => {
+		sqliteInitMock.mockReset();
+		ensureRpcRuntimeAddressMock.mockReset();
+		resolveRpcOwnerContextMock.mockClear();
+		rpcHealthByAddress.clear();
+		logger.debug.mockReset();
+		logger.log.mockReset();
+		logger.error.mockReset();
+		delete process.env.CLINE_SESSION_BACKEND_MODE;
+		delete process.env.CLINE_VCR;
+		vi.resetModules();
+	});
+
+	it("falls back to file session storage when sqlite initialization fails", async () => {
+		sqliteInitMock.mockImplementation(() => {
+			throw new Error("sqlite unavailable");
+		});
+		const { resolveSessionBackend } = await import("../runtime/host");
+
+		const backend = await resolveSessionBackend({ backendMode: "local" });
+		expect(backend.constructor.name).toBe("FileSessionService");
+	});
+
+	it("silently falls back to file session storage when node:sqlite is unavailable", async () => {
+		sqliteInitMock.mockImplementation(() => {
+			const error = new Error(
+				"No such built-in module: node:sqlite",
+			) as Error & {
+				code?: string;
+			};
+			error.code = "ERR_UNKNOWN_BUILTIN_MODULE";
+			throw error;
+		});
+		const { resolveSessionBackend } = await import("../runtime/host");
+
+		const backend = await resolveSessionBackend({ backendMode: "local" });
+		expect(backend.constructor.name).toBe("FileSessionService");
+	});
+
+	it("connects to the ensured rpc address when the sidecar relocates ports", async () => {
+		const { resolveSessionBackend } = await import("../runtime/host");
+		ensureRpcRuntimeAddressMock.mockResolvedValue({
+			address: "ws://127.0.0.1:12345",
+			action: "new-port",
+			owner: {
+				ownerId: "core-owner",
+				buildId: "core-build",
+				discoveryPath: "/tmp/rpc-owner.json",
+			},
+		});
+		rpcHealthByAddress.set("ws://127.0.0.1:12345", {
+			running: true,
+			serverId: "rpc-server",
+		});
+
+		const backend = await resolveSessionBackend({
+			backendMode: "auto",
+			rpc: {
+				address: "ws://127.0.0.1:4317",
+				connectAttempts: 1,
+				connectDelayMs: 0,
+			},
+		});
+
+		expect(ensureRpcRuntimeAddressMock).toHaveBeenCalledWith(
+			"ws://127.0.0.1:4317",
+			expect.objectContaining({
+				spawnIfNeeded: expect.any(Function),
+				resolveOwner: expect.any(Function),
+			}),
+		);
+		expect(backend).not.toBeInstanceOf(FileSessionService);
+	});
+
+	it("logs the rpc auto-start failure before falling back to local", async () => {
+		const { resolveSessionBackend } = await import("../runtime/host");
+		ensureRpcRuntimeAddressMock.mockRejectedValue(
+			new Error(
+				"failed to ensure rpc runtime at ws://127.0.0.1:4317: health probe reported no running server",
+			),
+		);
+
+		const backend = await resolveSessionBackend({
+			backendMode: "auto",
+			logger,
+			rpc: {
+				address: "ws://127.0.0.1:4317",
+				connectAttempts: 1,
+				connectDelayMs: 0,
+			},
+		});
+
+		expect(backend).not.toBeInstanceOf(FileSessionService);
+		expect(logger.log).toHaveBeenCalledWith(
+			"Ensuring RPC runtime for auto session backend",
+			{ address: "ws://127.0.0.1:4317" },
+		);
+		expect(logger.error).toHaveBeenCalledWith(
+			"RPC backend auto-start failed",
+			expect.objectContaining({
+				address: "ws://127.0.0.1:4317",
+				requestedAddress: "ws://127.0.0.1:4317",
+				error: expect.any(Error),
+			}),
+		);
+		expect(logger.log).toHaveBeenCalledWith(
+			"Falling back to local session backend",
+			{
+				requestedAddress: "ws://127.0.0.1:4317",
+				address: "ws://127.0.0.1:4317",
+				attempts: 1,
+				delayMs: 0,
+				severity: "warn",
+			},
+		);
+	});
+
+	it("honors env-managed local mode inside core backend resolution", async () => {
+		process.env.CLINE_SESSION_BACKEND_MODE = "local";
+		const { resolveSessionBackend } = await import("../runtime/host");
+
+		const backend = await resolveSessionBackend({});
+
+		expect(backend).not.toBeInstanceOf(FileSessionService);
+		expect(ensureRpcRuntimeAddressMock).not.toHaveBeenCalled();
+	});
+
+	it("forces local backend when vcr is enabled", async () => {
+		process.env.CLINE_VCR = "1";
+		const { resolveSessionBackend } = await import("../runtime/host");
+
+		const backend = await resolveSessionBackend({});
+
+		expect(backend).not.toBeInstanceOf(FileSessionService);
+		expect(ensureRpcRuntimeAddressMock).not.toHaveBeenCalled();
+	});
+
+	it("forces a local runtime host when local-only host options are provided", async () => {
+		rpcHealthByAddress.set("ws://127.0.0.1:4317", {
+			running: true,
+			serverId: "rpc-server",
+		});
+		const { createRuntimeHost, LocalRuntimeHost } = await import("../index");
+
+		const host = await createRuntimeHost({
+			backendMode: "auto",
+			logger,
+			rpc: {
+				address: "ws://127.0.0.1:4317",
+				connectAttempts: 1,
+				connectDelayMs: 0,
+			},
+			teamToolsFactory: vi.fn(() => ({
+				tools: [],
+				restoredFromPersistence: false,
+				restoredTeammates: [],
+			})),
+		});
+
+		expect(host).toBeInstanceOf(LocalRuntimeHost);
+		expect(ensureRpcRuntimeAddressMock).not.toHaveBeenCalled();
+		expect(logger.log).toHaveBeenCalledWith(
+			"Using local runtime host due to local-only options",
+			{
+				configuredMode: "auto",
+				hasDefaultToolExecutors: false,
+				hasTeamToolsFactory: true,
+			},
+		);
+	});
+
+	it("rejects rpc runtime mode when local-only host options are provided", async () => {
+		const { createRuntimeHost } = await import("../index");
+
+		await expect(
+			createRuntimeHost({
+				backendMode: "rpc",
+				teamToolsFactory: vi.fn(() => ({
+					tools: [],
+					restoredFromPersistence: false,
+					restoredTeammates: [],
+				})),
+			}),
+		).rejects.toThrow(
+			"RPC runtime mode does not support local-only runtime host options such as custom tool executors or team tools factories.",
+		);
+	});
+});