@clinebot/core 0.0.36 → 0.0.37

package/src/hub/daemon.ts

@@ -2,23 +2,32 @@ import { spawn } from "node:child_process";
 import { closeSync, mkdirSync, openSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { withResolvedClineBuildEnv } from "@clinebot/shared";
-import { verifyHubConnection } from "./client";
+import {
+	CLINE_RUN_AS_HUB_DAEMON_ENV,
+	isHubDaemonProcess,
+	withResolvedClineBuildEnv,
+} from "@clinebot/shared";
+import { requestHubShutdown, verifyHubConnection } from "./client";
 import {
 	type HubEndpointOverrides,
 	resolveHubEndpointOptions,
 } from "./defaults";
 import {
+	clearHubDiscovery,
 	createHubServerUrl,
+	type HubServerDiscoveryRecord,
 	probeHubServer,
 	readHubDiscovery,
 	resolveClineDataDir,
+	resolveHubBuildId,
 	writeHubDiscovery,
 } from "./discovery";
 import { resolveSharedHubOwnerContext } from "./workspace";
 
 const HUB_STARTUP_TIMEOUT_MS = 8_000;
 const HUB_STARTUP_POLL_MS = 200;
+const HUB_RETIRE_TIMEOUT_MS = 3_000;
+const HUB_RETIRE_POLL_MS = 100;
 
 function endpointArgs(endpoint: HubEndpointOverrides): string[] {
 	return [
@@ -40,6 +49,45 @@ function openDetachedHubLogFile(): { fd: number; logPath: string } | undefined {
 	}
 }
 
+function isCompatibleHubRecord(record: HubServerDiscoveryRecord): boolean {
+	const recordBuildId = record.buildId?.trim();
+	return !!recordBuildId && recordBuildId === resolveHubBuildId();
+}
+
+async function waitForHubToRetire(
+	url: string,
+	timeoutMs: number,
+): Promise<boolean> {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		const healthy = await probeHubServer(url).catch(() => undefined);
+		if (!healthy?.url) {
+			return true;
+		}
+		await new Promise((resolve) => setTimeout(resolve, HUB_RETIRE_POLL_MS));
+	}
+	return false;
+}
+
+async function retireIncompatibleHub(
+	record: HubServerDiscoveryRecord,
+	discoveryPath: string,
+): Promise<void> {
+	if (isCompatibleHubRecord(record)) {
+		return;
+	}
+	await requestHubShutdown(record.url).catch(() => false);
+	if (record.pid) {
+		try {
+			process.kill(record.pid, "SIGTERM");
+		} catch {
+			// Best-effort cleanup only. A compatible hub may still start on a fallback port.
+		}
+	}
+	await waitForHubToRetire(record.url, HUB_RETIRE_TIMEOUT_MS);
+	await clearHubDiscovery(discoveryPath).catch(() => undefined);
+}
+
 function resolveDaemonEntryPath(): string {
 	const extension = import.meta.url.endsWith(".ts") ? "ts" : "js";
 	return fileURLToPath(new URL(`./daemon-entry.${extension}`, import.meta.url));
@@ -75,6 +123,7 @@ function resolveLaunchCommand(
 		env: {
 			...withResolvedClineBuildEnv(process.env),
 			CLINE_NO_INTERACTIVE: "1",
+			[CLINE_RUN_AS_HUB_DAEMON_ENV]: "1",
 		},
 	};
 }
@@ -83,6 +132,9 @@ export function spawnDetachedHubServer(
 	workspaceRoot: string,
 	endpoint: HubEndpointOverrides = {},
 ): void {
+	if (isHubDaemonProcess()) {
+		return;
+	}
 	const command = resolveLaunchCommand(workspaceRoot, endpoint);
 	const logFile = openDetachedHubLogFile();
 	try {
@@ -104,7 +156,12 @@ export function prewarmDetachedHubServer(
 	workspaceRoot: string,
 	endpoint: HubEndpointOverrides = {},
 ): void {
+	if (isHubDaemonProcess()) {
+		return;
+	}
 	const owner = resolveSharedHubOwnerContext();
+	const hasExplicitPort =
+		endpoint.port !== undefined || !!process.env.CLINE_HUB_PORT?.trim();
 	const resolvedEndpoint = resolveHubEndpointOptions(endpoint);
 	const expectedUrl = createHubServerUrl(
 		resolvedEndpoint.host,
@@ -115,19 +172,36 @@ export function prewarmDetachedHubServer(
 		.then(async (discovered) => {
 			if (discovered?.url) {
 				const healthy = await probeHubServer(discovered.url);
-				if (healthy?.url && (await verifyHubConnection(healthy.url))) {
+				if (
+					healthy?.url &&
+					isCompatibleHubRecord(healthy) &&
+					(await verifyHubConnection(healthy.url))
+				) {
 					return;
 				}
+				if (healthy?.url) {
+					await retireIncompatibleHub(healthy, owner.discoveryPath);
+				} else {
+					await clearHubDiscovery(owner.discoveryPath).catch(() => undefined);
+				}
 			}
 			const expected = await probeHubServer(expectedUrl);
-			if (expected?.url && (await verifyHubConnection(expected.url))) {
+			if (
+				expected?.url &&
+				isCompatibleHubRecord(expected) &&
+				(await verifyHubConnection(expected.url))
+			) {
 				await writeHubDiscovery(owner.discoveryPath, expected);
 				return;
 			}
-			const spawnEndpoint =
-				expected?.url && resolvedEndpoint.port !== 0
-					? { ...resolvedEndpoint, port: 0 }
-					: resolvedEndpoint;
+			if (expected?.url) {
+				await retireIncompatibleHub(expected, owner.discoveryPath);
+			}
+			const shouldUseFallbackPort =
+				!hasExplicitPort && resolvedEndpoint.port !== 0;
+			const spawnEndpoint = shouldUseFallbackPort
+				? { ...resolvedEndpoint, port: 0 }
+				: resolvedEndpoint;
 			spawnDetachedHubServer(workspaceRoot, spawnEndpoint);
 		})
 		.catch(() => {
@@ -140,6 +214,9 @@ export async function ensureDetachedHubServer(
 	endpointOverrides: HubEndpointOverrides = {},
 ): Promise<string> {
 	const owner = resolveSharedHubOwnerContext();
+	const hasExplicitPort =
+		endpointOverrides.port !== undefined ||
+		!!process.env.CLINE_HUB_PORT?.trim();
 	const endpoint = resolveHubEndpointOptions(endpointOverrides);
 	const expectedUrl = createHubServerUrl(
 		endpoint.host,
@@ -149,29 +226,55 @@ export async function ensureDetachedHubServer(
 	const discovered = await readHubDiscovery(owner.discoveryPath);
 	if (discovered?.url) {
 		const healthy = await probeHubServer(discovered.url);
-		if (healthy?.url && (await verifyHubConnection(healthy.url))) {
+		if (
+			healthy?.url &&
+			isCompatibleHubRecord(healthy) &&
+			(await verifyHubConnection(healthy.url))
+		) {
 			return healthy.url;
 		}
+		if (healthy?.url) {
+			await retireIncompatibleHub(healthy, owner.discoveryPath);
+		} else {
+			await clearHubDiscovery(owner.discoveryPath).catch(() => undefined);
+		}
 	}
 	const expected = await probeHubServer(expectedUrl);
-	if (expected?.url && (await verifyHubConnection(expected.url))) {
+	if (
+		expected?.url &&
+		isCompatibleHubRecord(expected) &&
+		(await verifyHubConnection(expected.url))
+	) {
 		await writeHubDiscovery(owner.discoveryPath, expected);
 		return expected.url;
 	}
-	const spawnEndpoint =
-		expected?.url && endpoint.port !== 0 ? { ...endpoint, port: 0 } : endpoint;
+	if (expected?.url) {
+		await retireIncompatibleHub(expected, owner.discoveryPath);
+	}
+	const shouldUseFallbackPort = !hasExplicitPort && endpoint.port !== 0;
+	const spawnEndpoint = shouldUseFallbackPort
+		? { ...endpoint, port: 0 }
+		: endpoint;
 	spawnDetachedHubServer(workspaceRoot, spawnEndpoint);
 	const deadline = Date.now() + HUB_STARTUP_TIMEOUT_MS;
 	while (Date.now() < deadline) {
 		const nextDiscovery = await readHubDiscovery(owner.discoveryPath);
 		if (nextDiscovery?.url) {
 			const healthy = await probeHubServer(nextDiscovery.url);
-			if (healthy?.url && (await verifyHubConnection(healthy.url))) {
+			if (
+				healthy?.url &&
+				isCompatibleHubRecord(healthy) &&
+				(await verifyHubConnection(healthy.url))
+			) {
 				return healthy.url;
 			}
 		}
 		const nextExpected = await probeHubServer(expectedUrl);
-		if (nextExpected?.url && (await verifyHubConnection(nextExpected.url))) {
+		if (
+			nextExpected?.url &&
+			isCompatibleHubRecord(nextExpected) &&
+			(await verifyHubConnection(nextExpected.url))
+		) {
 			await writeHubDiscovery(owner.discoveryPath, nextExpected);
 			return nextExpected.url;
 		}

package/src/hub/defaults.ts

@@ -1,9 +1,15 @@
+import {
+	CLINE_HUB_DEV_PORT,
+	CLINE_HUB_PORT,
+	resolveClineBuildEnv,
+} from "@clinebot/shared";
+
 const HUB_HOST_ENV = "CLINE_HUB_HOST";
 const HUB_PORT_ENV = "CLINE_HUB_PORT";
 const HUB_PATHNAME_ENV = "CLINE_HUB_PATHNAME";
 
 export const DEFAULT_HUB_HOST = "127.0.0.1";
-export const DEFAULT_HUB_PORT = 25463;
+export const DEFAULT_HUB_PORT = CLINE_HUB_PORT;
 export const DEFAULT_HUB_PATHNAME = "/hub";
 
 export interface HubEndpointOverrides {
@@ -12,32 +18,53 @@ export interface HubEndpointOverrides {
 	pathname?: string;
 }
 
-export function resolveDefaultHubHost(): string {
-	return process.env[HUB_HOST_ENV]?.trim() || DEFAULT_HUB_HOST;
+export interface ResolveHubDefaultsOptions {
+	env?: NodeJS.ProcessEnv;
+	execArgv?: string[];
+}
+
+function fallbackHubPort(options: ResolveHubDefaultsOptions): number {
+	return resolveClineBuildEnv(options) === "development"
+		? CLINE_HUB_DEV_PORT
+		: DEFAULT_HUB_PORT;
+}
+
+export function resolveDefaultHubHost(
+	options: ResolveHubDefaultsOptions = {},
+): string {
+	const env = options.env ?? process.env;
+	return env[HUB_HOST_ENV]?.trim() || DEFAULT_HUB_HOST;
 }
 
-export function resolveDefaultHubPort(): number {
-	const raw = process.env[HUB_PORT_ENV]?.trim();
+export function resolveDefaultHubPort(
+	options: ResolveHubDefaultsOptions = {},
+): number {
+	const env = options.env ?? process.env;
+	const raw = env[HUB_PORT_ENV]?.trim();
 	if (!raw) {
-		return DEFAULT_HUB_PORT;
+		return fallbackHubPort(options);
 	}
 	const port = Number.parseInt(raw, 10);
 	if (!Number.isInteger(port) || port < 1 || port > 65_535) {
-		return DEFAULT_HUB_PORT;
+		return fallbackHubPort(options);
 	}
 	return port;
 }
 
-export function resolveDefaultHubPathname(): string {
-	return process.env[HUB_PATHNAME_ENV]?.trim() || DEFAULT_HUB_PATHNAME;
+export function resolveDefaultHubPathname(
+	options: ResolveHubDefaultsOptions = {},
+): string {
+	const env = options.env ?? process.env;
+	return env[HUB_PATHNAME_ENV]?.trim() || DEFAULT_HUB_PATHNAME;
 }
 
 export function resolveHubEndpointOptions(
 	overrides: HubEndpointOverrides = {},
+	options: ResolveHubDefaultsOptions = {},
 ): Required<HubEndpointOverrides> {
 	return {
-		host: overrides.host ?? resolveDefaultHubHost(),
-		port: overrides.port ?? resolveDefaultHubPort(),
-		pathname: overrides.pathname ?? resolveDefaultHubPathname(),
+		host: overrides.host ?? resolveDefaultHubHost(options),
+		port: overrides.port ?? resolveDefaultHubPort(options),
+		pathname: overrides.pathname ?? resolveDefaultHubPathname(options),
 	};
 }

package/src/hub/runtime-handlers.ts

@@ -22,7 +22,6 @@ function toChatTurnResult(result: {
 	};
 	iterations: number;
 	finishReason: string;
-	messages: unknown[];
 	toolCalls: Array<{
 		name: string;
 		input?: unknown;
@@ -38,7 +37,6 @@ function toChatTurnResult(result: {
 		outputTokens: result.usage.outputTokens,
 		iterations: result.iterations,
 		finishReason: result.finishReason,
-		messages: result.messages as never,
 		toolCalls: result.toolCalls.map((call) => ({
 			name: call.name,
 			input: call.input,
@@ -81,7 +79,7 @@ export function createLocalHubScheduleRuntimeHandlers(
 		async startSession(request) {
 			const cwd = (request.cwd?.trim() || request.workspaceRoot).trim();
 			const started = await sessionHost.start({
-				source: SessionSource.CLI,
+				source: request.source?.trim() || SessionSource.CLI,
 				interactive: false,
 				config: {
 					providerId: normalizeProviderId(request.provider),
@@ -104,6 +102,9 @@ export function createLocalHubScheduleRuntimeHandlers(
 						autoApprove: request.autoApproveTools !== false,
 					},
 				},
+				localRuntime: {
+					configExtensions: request.configExtensions,
+				},
 			});
 			return {
 				sessionId: started.sessionId,