@clinebot/core 0.0.35 → 0.0.37

package/src/hub/discovery.ts

@@ -0,0 +1,247 @@
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { resolveClineDataDir, resolveClineDir } from "@clinebot/shared/storage";
+import corePackage from "../../package.json";
+
+const HUB_DISCOVERY_ENV = "CLINE_HUB_DISCOVERY_PATH";
+const HUB_BUILD_ID_ENV = "CLINE_HUB_BUILD_ID";
+const HUB_STARTUP_LOCK_MAX_AGE_MS = 30_000;
+const HUB_STARTUP_LOCK_WAIT_MS = 15_000;
+const HUB_STARTUP_LOCK_POLL_MS = 100;
+
+export interface HubServerDiscoveryRecord {
+	hubId: string;
+	protocolVersion: string;
+	buildId?: string;
+	host: string;
+	port: number;
+	url: string;
+	pid?: number;
+	startedAt: string;
+	updatedAt: string;
+}
+
+export interface HubOwnerContext {
+	ownerId: string;
+	discoveryPath: string;
+}
+
+function sanitizeKey(value: string): string {
+	return value.replace(/[^a-zA-Z0-9_.-]+/g, "_");
+}
+
+function hashValue(value: string): string {
+	return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+
+function isPidAlive(pid: number | undefined): boolean {
+	if (!Number.isInteger(pid) || !pid || pid <= 0) {
+		return false;
+	}
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error instanceof Error && "code" in error
+			? String((error as NodeJS.ErrnoException).code) === "EPERM"
+			: false;
+	}
+}
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function getStartupLockDir(discoveryPath: string): string {
+	return `${discoveryPath}.lock`;
+}
+
+async function readStartupLockRecord(
+	lockDir: string,
+): Promise<{ pid: number; acquiredAt: string } | undefined> {
+	try {
+		const parsed = JSON.parse(
+			await readFile(join(lockDir, "owner.json"), "utf8"),
+		) as Partial<{ pid: number; acquiredAt: string }>;
+		if (
+			typeof parsed.pid !== "number" ||
+			typeof parsed.acquiredAt !== "string"
+		) {
+			return undefined;
+		}
+		return { pid: parsed.pid, acquiredAt: parsed.acquiredAt };
+	} catch {
+		return undefined;
+	}
+}
+
+async function removeStartupLock(lockDir: string): Promise<void> {
+	await rm(lockDir, { recursive: true, force: true }).catch(() => undefined);
+}
+
+export function resolveHubBuildId(): string {
+	return process.env[HUB_BUILD_ID_ENV]?.trim() || String(corePackage.version);
+}
+
+export function resolveHubOwnerContext(
+	ownerBasis: string = process.argv[1]?.trim() || process.cwd(),
+): HubOwnerContext {
+	const ownerId = `hub-${hashValue(ownerBasis)}`;
+	const discoveryPath =
+		process.env[HUB_DISCOVERY_ENV]?.trim() ||
+		join(
+			resolveClineDataDir(),
+			"locks",
+			"hub",
+			"owners",
+			`${sanitizeKey(ownerId)}.json`,
+		);
+	return { ownerId, discoveryPath };
+}
+
+export function createInMemoryHubOwnerContext(
+	label = `hub-${Date.now().toString(36)}`,
+): HubOwnerContext {
+	return resolveHubOwnerContext(label);
+}
+
+export async function readHubDiscovery(
+	discoveryPath: string,
+): Promise<HubServerDiscoveryRecord | undefined> {
+	try {
+		const parsed = JSON.parse(
+			await readFile(discoveryPath, "utf8"),
+		) as Partial<HubServerDiscoveryRecord>;
+		if (
+			typeof parsed.hubId !== "string" ||
+			typeof parsed.protocolVersion !== "string" ||
+			typeof parsed.host !== "string" ||
+			typeof parsed.port !== "number" ||
+			typeof parsed.url !== "string" ||
+			typeof parsed.startedAt !== "string" ||
+			typeof parsed.updatedAt !== "string"
+		) {
+			return undefined;
+		}
+		return {
+			hubId: parsed.hubId,
+			protocolVersion: parsed.protocolVersion,
+			buildId: typeof parsed.buildId === "string" ? parsed.buildId : undefined,
+			host: parsed.host,
+			port: parsed.port,
+			url: parsed.url,
+			pid: typeof parsed.pid === "number" ? parsed.pid : undefined,
+			startedAt: parsed.startedAt,
+			updatedAt: parsed.updatedAt,
+		};
+	} catch {
+		return undefined;
+	}
+}
+
+export async function writeHubDiscovery(
+	discoveryPath: string,
+	record: HubServerDiscoveryRecord,
+): Promise<void> {
+	await mkdir(dirname(discoveryPath), { recursive: true });
+	await writeFile(
+		discoveryPath,
+		`${JSON.stringify(record, null, 2)}\n`,
+		"utf8",
+	);
+}
+
+export async function clearHubDiscovery(discoveryPath: string): Promise<void> {
+	await rm(discoveryPath, { force: true }).catch(() => undefined);
+}
+
+export async function withHubStartupLock<T>(
+	discoveryPath: string,
+	callback: () => Promise<T>,
+): Promise<T> {
+	const lockDir = getStartupLockDir(discoveryPath);
+	await mkdir(dirname(lockDir), { recursive: true });
+	const deadline = Date.now() + HUB_STARTUP_LOCK_WAIT_MS;
+
+	while (true) {
+		try {
+			await mkdir(lockDir, { recursive: false });
+			await writeFile(
+				join(lockDir, "owner.json"),
+				`${JSON.stringify(
+					{ pid: process.pid, acquiredAt: new Date().toISOString() },
+					null,
+					2,
+				)}\n`,
+				"utf8",
+			);
+			try {
+				return await callback();
+			} finally {
+				await removeStartupLock(lockDir);
+			}
+		} catch (error) {
+			const code =
+				error instanceof Error && "code" in error
+					? String((error as NodeJS.ErrnoException).code)
+					: "";
+			if (code !== "EEXIST") {
+				throw error;
+			}
+			const record = await readStartupLockRecord(lockDir);
+			const lockAge = record
+				? Date.now() - Date.parse(record.acquiredAt)
+				: HUB_STARTUP_LOCK_MAX_AGE_MS + 1;
+			if (
+				!record ||
+				!isPidAlive(record.pid) ||
+				lockAge > HUB_STARTUP_LOCK_MAX_AGE_MS
+			) {
+				await removeStartupLock(lockDir);
+				continue;
+			}
+			if (Date.now() >= deadline) {
+				throw new Error(`Timed out waiting for hub startup lock ${lockDir}`);
+			}
+			await sleep(HUB_STARTUP_LOCK_POLL_MS);
+		}
+	}
+}
+
+export async function probeHubServer(
+	url: string,
+): Promise<HubServerDiscoveryRecord | undefined> {
+	try {
+		const response = await fetch(toHubHealthUrl(url));
+		if (!response.ok) {
+			return undefined;
+		}
+		return (await response.json()) as HubServerDiscoveryRecord;
+	} catch {
+		return undefined;
+	}
+}
+
+export function createHubServerUrl(
+	host: string,
+	port: number,
+	pathname = "/hub",
+): string {
+	return new URL(`ws://${host}:${port}${pathname}`).toString();
+}
+
+export function toHubHealthUrl(wsUrl: string): string {
+	const parsed = new URL(wsUrl);
+	parsed.protocol = parsed.protocol === "wss:" ? "https:" : "http:";
+	parsed.pathname = "/health";
+	parsed.search = "";
+	return parsed.toString();
+}
+
+export function isDiscoveryFilePresent(pathname: string): boolean {
+	return existsSync(pathname);
+}
+
+export { resolveClineDataDir, resolveClineDir };

package/src/hub/index.ts

@@ -0,0 +1,14 @@
+export * from "./browser-websocket";
+export * from "./client";
+export * from "./connect";
+export * from "./daemon";
+export * from "./defaults";
+export * from "./discovery";
+export * from "./native-transport";
+export * from "./runtime-handlers";
+export * from "./server";
+export * from "./session-client";
+export * from "./start-shared-server";
+export * from "./transport";
+export * from "./ui-client";
+export * from "./workspace";

package/src/hub/native-transport.ts

@@ -0,0 +1,31 @@
+import type {
+	HubCommandEnvelope,
+	HubEventEnvelope,
+	HubReplyEnvelope,
+} from "@clinebot/shared";
+import type { HubCommandTransport } from "./transport";
+
+export interface NativeHubTransport {
+	handleCommand(envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+	subscribe(
+		clientId: string,
+		listener: (event: HubEventEnvelope) => void,
+		options?: { sessionId?: string },
+	): () => void;
+}
+
+export class NativeHubTransportAdapter implements HubCommandTransport {
+	constructor(private readonly transport: NativeHubTransport) {}
+
+	command(envelope: HubCommandEnvelope): Promise<HubReplyEnvelope> {
+		return this.transport.handleCommand(envelope);
+	}
+
+	subscribe(
+		clientId: string,
+		listener: (event: HubEventEnvelope) => void,
+		options?: { sessionId?: string },
+	): () => void {
+		return this.transport.subscribe(clientId, listener, options);
+	}
+}

package/src/hub/runtime-handlers.ts

@@ -0,0 +1,141 @@
+import { normalizeProviderId } from "@clinebot/llms";
+import type {
+	ChatRunTurnRequest,
+	ChatStartSessionRequest,
+	ChatTurnResult,
+} from "@clinebot/shared";
+import type {
+	HubScheduleRuntimeHandlers,
+	HubScheduleServiceOptions,
+} from "../cron/schedule-service";
+import { SqliteSessionStore } from "../services/storage/sqlite-session-store";
+import { CoreSessionService } from "../session/session-service";
+import { LocalRuntimeHost } from "../transports/local";
+import { SessionSource } from "../types/common";
+
+function toChatTurnResult(result: {
+	text: string;
+	usage: {
+		inputTokens: number;
+		outputTokens: number;
+		totalCost?: number;
+	};
+	iterations: number;
+	finishReason: string;
+	toolCalls: Array<{
+		name: string;
+		input?: unknown;
+		output?: unknown;
+		error?: string;
+		durationMs?: number;
+	}>;
+}): ChatTurnResult {
+	return {
+		text: result.text,
+		usage: result.usage,
+		inputTokens: result.usage.inputTokens,
+		outputTokens: result.usage.outputTokens,
+		iterations: result.iterations,
+		finishReason: result.finishReason,
+		toolCalls: result.toolCalls.map((call) => ({
+			name: call.name,
+			input: call.input,
+			output: call.output,
+			error: call.error,
+			durationMs: call.durationMs,
+		})),
+	};
+}
+
+function resolveMode(
+	request: ChatStartSessionRequest | ChatRunTurnRequest["config"],
+): "act" | "plan" | "yolo" {
+	return request.mode === "plan"
+		? "plan"
+		: request.mode === "yolo"
+			? "yolo"
+			: "act";
+}
+
+export interface CreateLocalHubScheduleRuntimeHandlersOptions
+	extends Pick<HubScheduleServiceOptions, "logger"> {
+	/**
+	 * Custom `fetch` implementation forwarded to the scheduler's internal
+	 * `LocalRuntimeHost`. Used by the AI gateway providers for every
+	 * scheduled session executed inside this hub process.
+	 */
+	fetch?: typeof fetch;
+}
+
+export function createLocalHubScheduleRuntimeHandlers(
+	options: CreateLocalHubScheduleRuntimeHandlersOptions = {},
+): HubScheduleRuntimeHandlers {
+	const sessionHost = new LocalRuntimeHost({
+		sessionService: new CoreSessionService(new SqliteSessionStore()),
+		fetch: options.fetch,
+	});
+
+	return {
+		async startSession(request) {
+			const cwd = (request.cwd?.trim() || request.workspaceRoot).trim();
+			const started = await sessionHost.start({
+				source: request.source?.trim() || SessionSource.CLI,
+				interactive: false,
+				config: {
+					providerId: normalizeProviderId(request.provider),
+					modelId: request.model,
+					apiKey: request.apiKey?.trim() || undefined,
+					cwd,
+					workspaceRoot: request.workspaceRoot,
+					systemPrompt: request.systemPrompt ?? "",
+					mode: resolveMode(request),
+					maxIterations: request.maxIterations,
+					enableTools: request.enableTools !== false,
+					enableSpawnAgent: request.enableSpawn !== false,
+					enableAgentTeams: request.enableTeams !== false,
+					disableMcpSettingsTools: request.disableMcpSettingsTools,
+					missionLogIntervalSteps: request.missionStepInterval,
+					missionLogIntervalMs: request.missionTimeIntervalMs,
+				},
+				toolPolicies: request.toolPolicies ?? {
+					"*": {
+						autoApprove: request.autoApproveTools !== false,
+					},
+				},
+				localRuntime: {
+					configExtensions: request.configExtensions,
+				},
+			});
+			return {
+				sessionId: started.sessionId,
+				startResult: {
+					sessionId: started.sessionId,
+					manifestPath: started.manifestPath,
+					messagesPath: started.messagesPath,
+				},
+			};
+		},
+		async sendSession(sessionId, request) {
+			const result = await sessionHost.send({
+				sessionId,
+				prompt: request.prompt,
+				userImages: request.attachments?.userImages,
+				userFiles: request.attachments?.userFiles?.map((file) => file.content),
+			});
+			if (!result) {
+				throw new Error("local hub schedule runtime returned no turn result");
+			}
+			return {
+				result: toChatTurnResult(result),
+			};
+		},
+		async abortSession(sessionId) {
+			await sessionHost.abort(sessionId, new Error("hub schedule abort"));
+			return { applied: true };
+		},
+		async stopSession(sessionId) {
+			await sessionHost.stop(sessionId);
+			return { applied: true };
+		},
+	};
+}