@clinebot/core 0.0.34 → 0.0.36

package/src/session/rpc-spawn-lease.ts

@@ -1,122 +0,0 @@
-import {
-	closeSync,
-	existsSync,
-	mkdirSync,
-	openSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-} from "node:fs";
-import { dirname, resolve } from "node:path";
-import { resolveSessionDataDir } from "@clinebot/shared/storage";
-
-const DEFAULT_LEASE_TTL_MS = 15_000;
-
-interface RpcSpawnLeaseRecord {
-	address: string;
-	pid: number;
-	createdAt: number;
-}
-
-export interface RpcSpawnLease {
-	path: string;
-	release: () => void;
-}
-
-function encodeAddress(address: string): string {
-	return Buffer.from(address).toString("base64url");
-}
-
-function getLeasePath(address: string): string {
-	return resolve(
-		resolveSessionDataDir(),
-		"rpc",
-		"spawn-leases",
-		`${encodeAddress(address)}.lock`,
-	);
-}
-
-function isProcessAlive(pid: number): boolean {
-	if (!Number.isInteger(pid) || pid <= 0) {
-		return false;
-	}
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-function shouldClearLease(path: string, ttlMs: number): boolean {
-	try {
-		const raw = readFileSync(path, "utf8");
-		const parsed = JSON.parse(raw) as Partial<RpcSpawnLeaseRecord>;
-		const createdAt = Number(parsed.createdAt ?? 0);
-		if (!Number.isFinite(createdAt) || createdAt <= 0) {
-			return true;
-		}
-		if (Date.now() - createdAt > ttlMs) {
-			return true;
-		}
-		return !isProcessAlive(Number(parsed.pid ?? 0));
-	} catch {
-		return true;
-	}
-}
-
-export function tryAcquireRpcSpawnLease(
-	address: string,
-	options?: { ttlMs?: number },
-): RpcSpawnLease | undefined {
-	const ttlMs = Math.max(1_000, options?.ttlMs ?? DEFAULT_LEASE_TTL_MS);
-	const path = getLeasePath(address);
-	mkdirSync(dirname(path), { recursive: true });
-
-	if (existsSync(path) && shouldClearLease(path, ttlMs)) {
-		rmSync(path, { force: true });
-	}
-
-	let fd: number | undefined;
-	try {
-		fd = openSync(path, "wx");
-		const record: RpcSpawnLeaseRecord = {
-			address,
-			pid: process.pid,
-			createdAt: Date.now(),
-		};
-		writeFileSync(fd, JSON.stringify(record), "utf8");
-	} catch {
-		if (typeof fd === "number") {
-			try {
-				closeSync(fd);
-			} catch {
-				// Best effort.
-			}
-		}
-		return undefined;
-	}
-
-	let released = false;
-	return {
-		path,
-		release: () => {
-			if (released) {
-				return;
-			}
-			released = true;
-			try {
-				if (typeof fd === "number") {
-					closeSync(fd);
-				}
-			} catch {
-				// Best effort.
-			}
-			try {
-				rmSync(path, { force: true });
-			} catch {
-				// Best effort.
-			}
-		},
-	};
-}

package/src/session/runtime-oauth-token-manager.test.ts

@@ -1,137 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import {
-	OAuthReauthRequiredError,
-	RuntimeOAuthTokenManager,
-} from "./runtime-oauth-token-manager";
-
-const {
-	getValidOpenAICodexCredentials,
-	getValidClineCredentials,
-	getValidOcaCredentials,
-} = vi.hoisted(() => ({
-	getValidOpenAICodexCredentials: vi.fn(),
-	getValidClineCredentials: vi.fn(),
-	getValidOcaCredentials: vi.fn(),
-}));
-
-vi.mock("../auth/codex", () => ({
-	getValidOpenAICodexCredentials,
-}));
-
-vi.mock("../auth/cline", () => ({
-	getValidClineCredentials,
-}));
-
-vi.mock("../auth/oca", () => ({
-	getValidOcaCredentials,
-}));
-
-describe("RuntimeOAuthTokenManager", () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-	});
-
-	it("refreshes and persists OpenAI Codex OAuth credentials", async () => {
-		const getProviderSettings = vi.fn().mockReturnValue({
-			provider: "openai-codex",
-			auth: {
-				accessToken: "access-old",
-				refreshToken: "refresh-old",
-				expiresAt: Date.now() - 1_000,
-				accountId: "acct-old",
-			},
-		});
-		const saveProviderSettings = vi.fn();
-
-		getValidOpenAICodexCredentials.mockResolvedValueOnce({
-			access: "access-new",
-			refresh: "refresh-new",
-			expires: 4_000_000_000_000,
-			accountId: "acct-new",
-		});
-
-		const manager = new RuntimeOAuthTokenManager({
-			providerSettingsManager: {
-				getProviderSettings,
-				saveProviderSettings,
-			} as never,
-		});
-
-		const result = await manager.resolveProviderApiKey({
-			providerId: "openai-codex",
-		});
-
-		expect(result).toMatchObject({
-			providerId: "openai-codex",
-			apiKey: "access-new",
-			accountId: "acct-new",
-			refreshed: true,
-		});
-		expect(saveProviderSettings).toHaveBeenCalledWith(
-			expect.objectContaining({
-				auth: expect.objectContaining({
-					accessToken: "access-new",
-					refreshToken: "refresh-new",
-					accountId: "acct-new",
-					expiresAt: 4_000_000_000_000,
-				}),
-			}),
-			{ setLastUsed: false, tokenSource: "oauth" },
-		);
-	});
-
-	it("throws re-auth required when refresh returns null", async () => {
-		getValidOpenAICodexCredentials.mockResolvedValueOnce(null);
-		const manager = new RuntimeOAuthTokenManager({
-			providerSettingsManager: {
-				getProviderSettings: vi.fn().mockReturnValue({
-					provider: "openai-codex",
-					auth: {
-						accessToken: "access-old",
-						refreshToken: "refresh-old",
-						expiresAt: Date.now() - 1_000,
-					},
-				}),
-				saveProviderSettings: vi.fn(),
-			} as never,
-		});
-
-		await expect(
-			manager.resolveProviderApiKey({ providerId: "openai-codex" }),
-		).rejects.toBeInstanceOf(OAuthReauthRequiredError);
-	});
-
-	it("de-duplicates concurrent refresh calls per provider", async () => {
-		const refreshBarrier = Promise.resolve().then(() => ({
-			access: "access-new",
-			refresh: "refresh-new",
-			expires: Date.now() + 60_000,
-		}));
-		getValidOpenAICodexCredentials.mockImplementationOnce(
-			async () => refreshBarrier,
-		);
-
-		const manager = new RuntimeOAuthTokenManager({
-			providerSettingsManager: {
-				getProviderSettings: vi.fn().mockReturnValue({
-					provider: "openai-codex",
-					auth: {
-						accessToken: "access-old",
-						refreshToken: "refresh-old",
-						expiresAt: Date.now() - 1_000,
-					},
-				}),
-				saveProviderSettings: vi.fn(),
-			} as never,
-		});
-
-		const [first, second] = await Promise.all([
-			manager.resolveProviderApiKey({ providerId: "openai-codex" }),
-			manager.resolveProviderApiKey({ providerId: "openai-codex" }),
-		]);
-
-		expect(first?.apiKey).toBe("access-new");
-		expect(second?.apiKey).toBe("access-new");
-		expect(getValidOpenAICodexCredentials).toHaveBeenCalledTimes(1);
-	});
-});

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

@@ -1,172 +0,0 @@
-import type { ITelemetryService } from "@clinebot/shared";
-import { resolveAndLoadAgentPlugins } from "../extensions/plugin/plugin-config-loader";
-import type {
-	PluginInitializationFailure,
-	PluginInitializationWarning,
-} from "../extensions/plugin/plugin-load-report";
-import {
-	createHookAuditHooks,
-	createHookConfigFileHooks,
-	mergeAgentHooks,
-} from "../runtime/hook-file-hooks";
-import type { ProviderSettingsManager } from "../storage/provider-settings-manager";
-import type { CoreSessionConfig } from "../types/config";
-import {
-	type ProviderConfig,
-	type ProviderSettings,
-	toProviderConfig,
-} from "../types/provider-settings";
-import type { StartSessionInput } from "./session-manager";
-import { hasRuntimeHooks, mergeAgentExtensions } from "./utils/helpers";
-
-function formatPluginFailure(failure: PluginInitializationFailure): string {
-	const label = failure.pluginName ?? failure.pluginPath;
-	return `${label}: ${failure.message}`;
-}
-
-function logPluginDiagnostics(
-	failures: PluginInitializationFailure[],
-	warnings: PluginInitializationWarning[],
-	logger: CoreSessionConfig["logger"],
-): void {
-	if (warnings.length > 0) {
-		for (const warning of warnings) {
-			logger?.log(warning.message, { severity: "warn" });
-		}
-	}
-	if (failures.length === 0) {
-		return;
-	}
-	const preview = failures.slice(0, 3).map(formatPluginFailure).join("; ");
-	const suffix = failures.length > 3 ? `; and ${failures.length - 3} more` : "";
-	logger?.log(
-		`Some plugins failed to initialize. ${preview}${suffix}. Use --verbose for more details.`,
-		{ severity: "warn" },
-	);
-	for (const failure of failures) {
-		logger?.log(
-			`Plugin initialization failed (${failure.phase}) for ${failure.pluginPath}`,
-			{
-				severity: "warn",
-				stack: failure.stack,
-				pluginPath: failure.pluginPath,
-				pluginName: failure.pluginName,
-			},
-		);
-	}
-}
-
-export function resolveWorkspacePath(config: CoreSessionConfig): string {
-	return config.workspaceRoot ?? config.cwd;
-}
-
-export async function buildEffectiveConfig(
-	input: StartSessionInput,
-	hookPath: string,
-	sessionId: string,
-	defaultTelemetry: ITelemetryService | undefined,
-	onPluginEvent?: (event: { name: string; payload?: unknown }) => void,
-): Promise<{
-	config: CoreSessionConfig;
-	pluginSandboxShutdown?: () => Promise<void>;
-}> {
-	const workspacePath = resolveWorkspacePath(input.config);
-
-	const fileHooks = createHookConfigFileHooks({
-		cwd: input.config.cwd,
-		workspacePath,
-		rootSessionId: sessionId,
-		hookLogPath: hookPath,
-		logger: input.config.logger,
-	});
-	const auditHooks = hasRuntimeHooks(input.config.hooks)
-		? undefined
-		: createHookAuditHooks({
-				hookLogPath: hookPath,
-				rootSessionId: sessionId,
-				workspacePath,
-			});
-	const effectiveHooks = mergeAgentHooks([
-		input.config.hooks,
-		fileHooks,
-		auditHooks,
-	]);
-
-	let loadedPlugins:
-		| Awaited<ReturnType<typeof resolveAndLoadAgentPlugins>>
-		| undefined;
-	try {
-		loadedPlugins = await resolveAndLoadAgentPlugins({
-			pluginPaths: input.config.pluginPaths,
-			workspacePath,
-			cwd: input.config.cwd,
-			onEvent: onPluginEvent,
-		});
-		logPluginDiagnostics(
-			loadedPlugins.failures,
-			loadedPlugins.warnings,
-			input.config.logger,
-		);
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		input.config.logger?.log?.(
-			`plugin loading failed; continuing without plugins (${message})`,
-		);
-	}
-	const effectiveExtensions = mergeAgentExtensions(
-		input.config.extensions,
-		loadedPlugins?.extensions,
-	);
-
-	return {
-		config: {
-			...input.config,
-			hooks: effectiveHooks,
-			extensions: effectiveExtensions,
-			telemetry: input.config.telemetry ?? defaultTelemetry,
-		},
-		pluginSandboxShutdown: loadedPlugins?.shutdown,
-	};
-}
-
-export function buildResolvedProviderConfig(
-	config: CoreSessionConfig,
-	providerSettingsManager: ProviderSettingsManager,
-	resolveReasoningFn: (
-		config: CoreSessionConfig,
-		storedReasoning: ProviderSettings["reasoning"],
-	) => ProviderSettings["reasoning"],
-): ProviderConfig {
-	const stored = providerSettingsManager.getProviderSettings(config.providerId);
-	const settings: ProviderSettings = {
-		...(stored ?? {}),
-		provider: config.providerId,
-		model: config.modelId,
-		apiKey: config.apiKey ?? stored?.apiKey,
-		baseUrl: config.baseUrl ?? stored?.baseUrl,
-		headers: config.headers ?? stored?.headers,
-		reasoning: resolveReasoningFn(config, stored?.reasoning),
-	};
-	const providerConfig = toProviderConfig(settings);
-	if (config.knownModels) {
-		providerConfig.knownModels = config.knownModels;
-	}
-	if (config.extensionContext) {
-		providerConfig.extensionContext = config.extensionContext;
-	}
-	return providerConfig;
-}
-
-export function resolveReasoningSettings(
-	config: CoreSessionConfig,
-	storedReasoning: ProviderSettings["reasoning"],
-): ProviderSettings["reasoning"] {
-	const hasThinking = typeof config.thinking === "boolean";
-	const hasEffort = typeof config.reasoningEffort === "string";
-	if (!hasThinking && !hasEffort) return storedReasoning;
-	return {
-		...(storedReasoning ?? {}),
-		...(hasThinking ? { enabled: config.thinking } : {}),
-		...(hasEffort ? { effort: config.reasoningEffort } : {}),
-	};
-}

package/src/session/session-host.test.ts

@@ -1,89 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { FileSessionService } from "./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("../storage/sqlite-session-store", () => ({
-	SqliteSessionStore: class {
-		init(): void {
-			sqliteInitMock();
-		}
-	},
-}));
-
-describe("resolveSessionBackend", () => {
-	afterEach(() => {
-		sqliteInitMock.mockReset();
-		ensureRpcRuntimeAddressMock.mockReset();
-		resolveRpcOwnerContextMock.mockClear();
-		rpcHealthByAddress.clear();
-		vi.resetModules();
-	});
-
-	it("falls back to file session storage when sqlite initialization fails", async () => {
-		const { resolveSessionBackend } = await import("./session-host");
-		sqliteInitMock.mockImplementation(() => {
-			throw new Error("sqlite unavailable");
-		});
-
-		const backend = await resolveSessionBackend({ backendMode: "local" });
-		expect(backend).toBeInstanceOf(FileSessionService);
-	});
-
-	it("connects to the ensured rpc address when the sidecar relocates ports", async () => {
-		const { resolveSessionBackend } = await import("./session-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);
-	});
-});