@clinebot/core 0.0.37 → 0.0.38

package/src/hub/discovery.ts

@@ -1,247 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,141 +0,0 @@
-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 };
-		},
-	};
-}