@clinebot/core 0.0.35 → 0.0.36

package/src/runtime/history.test.ts

@@ -1,114 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import type { SessionRecord } from "../types/sessions";
-import { hydrateSessionHistory } from "./history";
-
-function createRow(
-	overrides: Partial<SessionRecord> & Pick<SessionRecord, "sessionId">,
-): SessionRecord {
-	return {
-		source: "cli",
-		pid: 1,
-		startedAt: "2026-04-21T02:17:46.169Z",
-		status: "completed",
-		interactive: false,
-		provider: "",
-		model: "",
-		cwd: "/tmp/workspace",
-		workspaceRoot: "/tmp/workspace",
-		enableTools: true,
-		enableSpawn: false,
-		enableTeams: false,
-		isSubagent: false,
-		updatedAt: "2026-04-21T02:17:46.169Z",
-		...overrides,
-	};
-}
-
-describe("hydrateSessionHistory", () => {
-	it("preserves rows that already have history display metadata", async () => {
-		const readMessages = vi.fn();
-		const rows = await hydrateSessionHistory({ readMessages }, [
-			createRow({
-				sessionId: "sess_1",
-				provider: "cline",
-				model: "anthropic/claude-sonnet-4.6",
-				prompt: "hello",
-				metadata: {
-					title: "hello",
-					totalCost: 0.02,
-				},
-			}),
-		]);
-
-		expect(rows).toEqual([
-			expect.objectContaining({
-				sessionId: "sess_1",
-				provider: "cline",
-				model: "anthropic/claude-sonnet-4.6",
-				metadata: expect.objectContaining({
-					title: "hello",
-					totalCost: 0.02,
-				}),
-			}),
-		]);
-		expect(readMessages).not.toHaveBeenCalled();
-	});
-
-	it("hydrates missing provider, model, and cost from stored messages", async () => {
-		const readMessages = vi.fn().mockResolvedValue([
-			{
-				role: "user",
-				content: [{ type: "text", text: "hello" }],
-			},
-			{
-				role: "assistant",
-				content: [{ type: "text", text: "hi" }],
-				modelInfo: {
-					provider: "cline",
-					id: "anthropic/claude-sonnet-4.6",
-				},
-				metrics: {
-					cost: 0.02,
-				},
-			},
-		]);
-
-		const [row] = await hydrateSessionHistory({ readMessages }, [
-			createRow({
-				sessionId: "sess_2",
-				prompt: "hello",
-				metadata: {},
-			}),
-		]);
-
-		expect(readMessages).toHaveBeenCalledWith("sess_2");
-		expect(row).toMatchObject({
-			sessionId: "sess_2",
-			provider: "cline",
-			model: "anthropic/claude-sonnet-4.6",
-			metadata: {
-				title: "hello",
-				totalCost: 0.02,
-			},
-		});
-	});
-
-	it("falls back to nested metadata provider/model ids before reading messages", async () => {
-		const readMessages = vi.fn().mockResolvedValue([]);
-
-		const [row] = await hydrateSessionHistory({ readMessages }, [
-			createRow({
-				sessionId: "sess_3",
-				metadata: {
-					title: "hello",
-					provider: { id: "cline" },
-					model: { id: "anthropic/claude-haiku-4.5" },
-				},
-			}),
-		]);
-
-		expect(row.provider).toBe("cline");
-		expect(row.model).toBe("anthropic/claude-haiku-4.5");
-		expect(readMessages).toHaveBeenCalledWith("sess_3");
-	});
-});

package/src/runtime/host.test.ts

@@ -1,230 +0,0 @@
-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.",
-		);
-	});
-});

package/src/runtime/rpc-runtime-ensure.test.ts

@@ -1,123 +0,0 @@
-import {
-	existsSync,
-	mkdirSync,
-	mkdtempSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-} from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-const { mockGetRpcServerHealth } = vi.hoisted(() => ({
-	mockGetRpcServerHealth: vi.fn(),
-}));
-
-vi.mock("@clinebot/rpc", () => ({
-	getRpcServerHealth: mockGetRpcServerHealth,
-	requestRpcServerShutdown: vi.fn(),
-	RPC_BUILD_VERSION: "rpc-build-test",
-	RPC_PROTOCOL_VERSION: "rpc-protocol-test",
-	RpcSessionClient: class {},
-}));
-
-import { withRpcStartupLock } from "./rpc-runtime-ensure";
-
-describe("withRpcStartupLock", () => {
-	const tempDirs: string[] = [];
-
-	afterEach(() => {
-		delete process.env.CLINE_DATA_DIR;
-		vi.clearAllMocks();
-		for (const dir of tempDirs.splice(0)) {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("records running status after startup completes", async () => {
-		const dataDir = mkdtempSync(
-			path.join(os.tmpdir(), "rpc-runtime-ensure-status-"),
-		);
-		tempDirs.push(dataDir);
-		process.env.CLINE_DATA_DIR = dataDir;
-
-		const address = "127.0.0.1:4317";
-		const lockDir = path.join(
-			dataDir,
-			"locks",
-			"rpc-start-127.0.0.1_4317.lock",
-		);
-		const ownerPath = path.join(lockDir, "owner.json");
-
-		await withRpcStartupLock(address, async (lock) => {
-			const starting = JSON.parse(readFileSync(ownerPath, "utf8")) as {
-				status: string;
-			};
-			expect(starting.status).toBe("starting");
-
-			await lock.markRunning({
-				resolvedAddress: "127.0.0.1:4318",
-				serverId: "server-1",
-			});
-
-			const running = JSON.parse(readFileSync(ownerPath, "utf8")) as {
-				status: string;
-				resolvedAddress?: string;
-				serverId?: string;
-			};
-			expect(running).toMatchObject({
-				status: "running",
-				resolvedAddress: "127.0.0.1:4318",
-				serverId: "server-1",
-			});
-		});
-
-		expect(existsSync(lockDir)).toBe(false);
-	});
-
-	it("reclaims a running lock when its recorded server is unreachable", async () => {
-		const dataDir = mkdtempSync(
-			path.join(os.tmpdir(), "rpc-runtime-ensure-stale-"),
-		);
-		tempDirs.push(dataDir);
-		process.env.CLINE_DATA_DIR = dataDir;
-
-		const address = "127.0.0.1:4317";
-		const lockDir = path.join(
-			dataDir,
-			"locks",
-			"rpc-start-127.0.0.1_4317.lock",
-		);
-		const ownerPath = path.join(lockDir, "owner.json");
-		mkdirSync(lockDir, { recursive: true });
-		writeFileSync(
-			ownerPath,
-			JSON.stringify(
-				{
-					pid: process.pid,
-					address,
-					acquiredAt: new Date().toISOString(),
-					updatedAt: new Date().toISOString(),
-					status: "running",
-					resolvedAddress: address,
-					serverId: "server-stale",
-				},
-				null,
-				2,
-			),
-			"utf8",
-		);
-
-		mockGetRpcServerHealth.mockResolvedValue(undefined);
-
-		let acquired = 0;
-		await withRpcStartupLock(address, async () => {
-			acquired += 1;
-		});
-
-		expect(acquired).toBe(1);
-		expect(mockGetRpcServerHealth).toHaveBeenCalledWith(address);
-		expect(existsSync(lockDir)).toBe(false);
-	});
-});