codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/core/src/hub/daemon/index.ts

@@ -0,0 +1,345 @@
+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 {
+	CLINE_RUN_AS_HUB_DAEMON_ENV,
+	isHubDaemonProcess,
+	withResolvedClineBuildEnv,
+} from "@cline/shared";
+import {
+	rememberRecoverableLocalHubUrl,
+	requestHubShutdown,
+	verifyHubConnection,
+} from "../client";
+import {
+	clearHubDiscovery,
+	createHubServerUrl,
+	type HubServerDiscoveryRecord,
+	probeHubServer,
+	readHubDiscovery,
+	resolveClineDataDir,
+	resolveHubBuildId,
+} from "../discovery";
+import {
+	type HubEndpointOverrides,
+	resolveHubEndpointOptions,
+} from "../discovery/defaults";
+import { resolveSharedHubOwnerContext } from "../discovery/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;
+const HUB_SPAWN_RETRY_DELAYS_MS = [100, 250, 500, 1_000, 2_000];
+const COMPILED_BUN_HUB_DAEMON_ARG = "--cline-hub-daemon";
+
+function endpointArgs(endpoint: HubEndpointOverrides): string[] {
+	return [
+		...(endpoint.host ? ["--host", endpoint.host] : []),
+		...(typeof endpoint.port === "number"
+			? ["--port", String(endpoint.port)]
+			: []),
+		...(endpoint.pathname ? ["--pathname", endpoint.pathname] : []),
+	];
+}
+
+function openDetachedHubLogFile(): { fd: number; logPath: string } | undefined {
+	try {
+		const logPath = join(resolveClineDataDir(), "logs", "hub-daemon.log");
+		mkdirSync(dirname(logPath), { recursive: true });
+		return { fd: openSync(logPath, "a"), logPath };
+	} catch {
+		return undefined;
+	}
+}
+
+function isCompatibleHubRecord(record: HubServerDiscoveryRecord): boolean {
+	const recordBuildId = record.buildId?.trim();
+	return !!recordBuildId && recordBuildId === resolveHubBuildId();
+}
+
+async function safeProbeHubServer(
+	url: string,
+): Promise<HubServerDiscoveryRecord | undefined> {
+	try {
+		return await probeHubServer(url);
+	} catch {
+		return undefined;
+	}
+}
+
+async function waitForHubToRetire(
+	url: string,
+	timeoutMs: number,
+): Promise<boolean> {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		const healthy = await safeProbeHubServer(url);
+		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, record.authToken).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(`./entry.${extension}`, import.meta.url));
+}
+
+function resolveLaunchCommand(
+	workspaceRoot: string,
+	endpoint: HubEndpointOverrides,
+): {
+	launcher: string;
+	args: string[];
+	cwd: string;
+	env: NodeJS.ProcessEnv;
+} {
+	const daemonEntryPath = resolveDaemonEntryPath();
+	const execPath = process.execPath?.trim();
+	if (!execPath) {
+		throw new Error("unable to resolve runtime executable for hub daemon");
+	}
+	const isBunRuntime = basename(execPath).toLowerCase().includes("bun");
+	const isCompiledBunEmbeddedEntry = daemonEntryPath.startsWith("/$bunfs/");
+	const useDevelopmentConditions =
+		isBunRuntime && daemonEntryPath.toLowerCase().endsWith(".ts");
+	const entryArgs = isCompiledBunEmbeddedEntry
+		? [COMPILED_BUN_HUB_DAEMON_ARG]
+		: [
+				...(useDevelopmentConditions ? ["--conditions=development"] : []),
+				daemonEntryPath,
+			];
+	return {
+		launcher: execPath,
+		args: [...entryArgs, "--cwd", workspaceRoot, ...endpointArgs(endpoint)],
+		cwd: workspaceRoot,
+		env: {
+			...withResolvedClineBuildEnv(process.env),
+			CLINE_NO_INTERACTIVE: "1",
+			[CLINE_RUN_AS_HUB_DAEMON_ENV]: "1",
+		},
+	};
+}
+
+function isTextFileBusyError(error: unknown): boolean {
+	if (!error || typeof error !== "object") {
+		return false;
+	}
+	const code = "code" in error ? error.code : undefined;
+	if (code === "ETXTBSY") {
+		return true;
+	}
+	const message = "message" in error ? error.message : undefined;
+	return typeof message === "string" && message.includes("ETXTBSY");
+}
+
+export function spawnDetachedHubServer(
+	workspaceRoot: string,
+	endpoint: HubEndpointOverrides = {},
+): void {
+	if (isHubDaemonProcess()) {
+		return;
+	}
+	const command = resolveLaunchCommand(workspaceRoot, endpoint);
+	const logFile = openDetachedHubLogFile();
+	try {
+		const child = spawn(command.launcher, command.args, {
+			detached: true,
+			stdio: logFile ? ["ignore", logFile.fd, logFile.fd] : "ignore",
+			env: command.env,
+			cwd: command.cwd,
+		});
+		child.unref();
+	} finally {
+		if (logFile) {
+			closeSync(logFile.fd);
+		}
+	}
+}
+
+export async function spawnDetachedHubServerWithRetry(
+	workspaceRoot: string,
+	endpoint: HubEndpointOverrides = {},
+): Promise<void> {
+	for (let attempt = 0; ; attempt++) {
+		try {
+			spawnDetachedHubServer(workspaceRoot, endpoint);
+			return;
+		} catch (error) {
+			const delay = HUB_SPAWN_RETRY_DELAYS_MS[attempt];
+			if (!isTextFileBusyError(error) || delay === undefined) {
+				throw error;
+			}
+			await new Promise((resolve) => setTimeout(resolve, delay));
+		}
+	}
+}
+
+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,
+		resolvedEndpoint.port,
+		resolvedEndpoint.pathname,
+	);
+	void readHubDiscovery(owner.discoveryPath)
+		.then(async (discovered) => {
+			if (discovered?.url) {
+				const healthy = await safeProbeHubServer(discovered.url);
+				if (
+					healthy?.url &&
+					isCompatibleHubRecord(healthy) &&
+					(await verifyHubConnection(healthy.url, {
+						authToken: discovered.authToken,
+					}))
+				) {
+					return;
+				}
+				if (healthy?.url) {
+					await retireIncompatibleHub(
+						{ ...healthy, authToken: discovered.authToken },
+						owner.discoveryPath,
+					);
+				} else {
+					await clearHubDiscovery(owner.discoveryPath).catch(() => undefined);
+				}
+			}
+			const expected = await safeProbeHubServer(expectedUrl);
+			if (expected?.url) {
+				await retireIncompatibleHub(expected, owner.discoveryPath);
+			}
+			const shouldUseFallbackPort =
+				!hasExplicitPort && resolvedEndpoint.port !== 0;
+			const spawnEndpoint = shouldUseFallbackPort
+				? { ...resolvedEndpoint, port: 0 }
+				: resolvedEndpoint;
+			await spawnDetachedHubServerWithRetry(workspaceRoot, spawnEndpoint);
+		})
+		.catch(() => {
+			// best-effort prewarm only
+		});
+}
+
+export interface DetachedHubResolution {
+	url: string;
+	authToken: string;
+}
+
+export async function ensureDetachedHubServer(
+	workspaceRoot: string,
+	endpointOverrides: HubEndpointOverrides = {},
+): Promise<DetachedHubResolution> {
+	const owner = resolveSharedHubOwnerContext();
+	const hasExplicitEndpoint =
+		endpointOverrides.host !== undefined ||
+		endpointOverrides.port !== undefined ||
+		endpointOverrides.pathname !== undefined ||
+		!!process.env.CLINE_HUB_PORT?.trim();
+	const hasExplicitPort =
+		endpointOverrides.port !== undefined ||
+		!!process.env.CLINE_HUB_PORT?.trim();
+	const endpoint = resolveHubEndpointOptions(endpointOverrides);
+	const expectedUrl = createHubServerUrl(
+		endpoint.host,
+		endpoint.port,
+		endpoint.pathname,
+	);
+	const rememberIfManaged = (
+		result: DetachedHubResolution,
+	): DetachedHubResolution => {
+		if (!hasExplicitEndpoint) {
+			rememberRecoverableLocalHubUrl(result.url, result.authToken);
+		}
+		return result;
+	};
+	const discovered = await readHubDiscovery(owner.discoveryPath);
+	if (discovered?.url) {
+		const healthy = await safeProbeHubServer(discovered.url);
+		if (
+			healthy?.url &&
+			isCompatibleHubRecord(healthy) &&
+			(await verifyHubConnection(healthy.url, {
+				authToken: discovered.authToken,
+			}))
+		) {
+			return rememberIfManaged({
+				url: healthy.url,
+				authToken: discovered.authToken,
+			});
+		}
+		if (healthy?.url) {
+			await retireIncompatibleHub(
+				{ ...healthy, authToken: discovered.authToken },
+				owner.discoveryPath,
+			);
+		} else {
+			await clearHubDiscovery(owner.discoveryPath).catch(() => undefined);
+		}
+	}
+	const expected = await safeProbeHubServer(expectedUrl);
+	if (expected?.url) {
+		await retireIncompatibleHub(expected, owner.discoveryPath);
+	}
+	const shouldUseFallbackPort = !hasExplicitPort && endpoint.port !== 0;
+	const spawnEndpoint = shouldUseFallbackPort
+		? { ...endpoint, port: 0 }
+		: endpoint;
+	await spawnDetachedHubServerWithRetry(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 safeProbeHubServer(nextDiscovery.url);
+			if (
+				healthy?.url &&
+				isCompatibleHubRecord(healthy) &&
+				(await verifyHubConnection(healthy.url, {
+					authToken: nextDiscovery.authToken,
+				}))
+			) {
+				return rememberIfManaged({
+					url: healthy.url,
+					authToken: nextDiscovery.authToken,
+				});
+			}
+		}
+		const nextExpected = await safeProbeHubServer(expectedUrl);
+		if (nextExpected?.url && !isCompatibleHubRecord(nextExpected)) {
+			await retireIncompatibleHub(nextExpected, owner.discoveryPath);
+		}
+		await new Promise((resolve) => setTimeout(resolve, HUB_STARTUP_POLL_MS));
+	}
+	throw new Error("Timed out waiting for detached hub startup.");
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/hub/daemon/runtime-handlers.ts

@@ -0,0 +1,144 @@
+import { normalizeProviderId } from "@cline/llms";
+import type {
+	ChatRunTurnRequest,
+	ChatStartSessionRequest,
+	ChatTurnResult,
+	ITelemetryService,
+} from "@cline/shared";
+import type {
+	HubScheduleRuntimeHandlers,
+	HubScheduleServiceOptions,
+} from "../../cron/service/schedule-service";
+import { LocalRuntimeHost } from "../../runtime/host/local-runtime-host";
+import { SqliteSessionStore } from "../../services/storage/sqlite-session-store";
+import { CoreSessionService } from "../../session/services/session-service";
+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;
+	telemetry?: ITelemetryService;
+}
+
+export function createLocalHubScheduleRuntimeHandlers(
+	options: CreateLocalHubScheduleRuntimeHandlersOptions = {},
+): HubScheduleRuntimeHandlers {
+	const sessionHost = new LocalRuntimeHost({
+		sessionService: new CoreSessionService(new SqliteSessionStore()),
+		fetch: options.fetch,
+		telemetry: options.telemetry,
+	});
+
+	return {
+		async startSession(request) {
+			const cwd = (request.cwd?.trim() || request.workspaceRoot).trim();
+			const started = await sessionHost.startSession({
+				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.runTurn({
+				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.stopSession(sessionId);
+			return { applied: true };
+		},
+	};
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/hub/daemon/start-shared-server.ts

@@ -0,0 +1,61 @@
+import { resolveHubEndpointOptions } from "../discovery/defaults";
+import { resolveSharedHubOwnerContext } from "../discovery/workspace";
+import {
+	type EnsuredHubWebSocketServerResult,
+	type EnsureHubWebSocketServerOptions,
+	ensureHubWebSocketServer,
+	type HubWebSocketServer,
+	type HubWebSocketServerOptions,
+	startHubWebSocketServer,
+} from "../server";
+
+export type HubServer = HubWebSocketServer;
+export type EnsureHubServerResult = EnsuredHubWebSocketServerResult;
+
+export interface StartHubServerOptions
+	extends Omit<HubWebSocketServerOptions, "owner"> {}
+
+export interface EnsureHubServerOptions
+	extends Omit<EnsureHubWebSocketServerOptions, "owner"> {}
+
+/**
+ * Start a hub WebSocket server bound to the process-local shared owner
+ * context. Callers that need a custom owner should invoke
+ * {@link startHubWebSocketServer} directly.
+ */
+export async function startHubServer(
+	options: StartHubServerOptions,
+): Promise<HubServer> {
+	const endpoint = resolveHubEndpointOptions({
+		host: options.host,
+		port: options.port,
+		pathname: options.pathname,
+	});
+	return await startHubWebSocketServer({
+		...options,
+		...endpoint,
+		owner: resolveSharedHubOwnerContext(),
+	});
+}
+
+/**
+ * Ensure a hub WebSocket server is running in the process-local shared owner
+ * context, reusing a compatible in-process instance when available.
+ */
+export async function ensureHubServer(
+	options: EnsureHubServerOptions,
+): Promise<EnsureHubServerResult> {
+	const hasExplicitPort =
+		options.port !== undefined || !!process.env.CLINE_HUB_PORT?.trim();
+	const endpoint = resolveHubEndpointOptions({
+		host: options.host,
+		port: options.port,
+		pathname: options.pathname,
+	});
+	return await ensureHubWebSocketServer({
+		...options,
+		...endpoint,
+		allowPortFallback: options.allowPortFallback ?? !hasExplicitPort,
+		owner: resolveSharedHubOwnerContext(),
+	});
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/hub/discovery/defaults.test.ts

@@ -0,0 +1,122 @@
+import { CLINE_BUILD_ENV_ENV } from "@cline/shared";
+import { describe, expect, it } from "vitest";
+import {
+	DEFAULT_HUB_PORT,
+	resolveDefaultHubPort,
+	resolveHubEndpointOptions,
+} from "./defaults";
+
+const DEV_HUB_PORT = 25466;
+
+describe("resolveDefaultHubPort", () => {
+	it("returns the dev hub port when CLINE_BUILD_ENV is development and CLINE_HUB_PORT is unset", () => {
+		expect(
+			resolveDefaultHubPort({
+				env: { [CLINE_BUILD_ENV_ENV]: "development" },
+				execArgv: [],
+			}),
+		).toBe(DEV_HUB_PORT);
+	});
+
+	it("returns the production hub port when CLINE_BUILD_ENV is production and CLINE_HUB_PORT is unset", () => {
+		expect(
+			resolveDefaultHubPort({
+				env: { [CLINE_BUILD_ENV_ENV]: "production" },
+				execArgv: [],
+			}),
+		).toBe(DEFAULT_HUB_PORT);
+	});
+
+	it("returns the production hub port when the build env cannot be determined", () => {
+		expect(resolveDefaultHubPort({ env: {}, execArgv: [] })).toBe(
+			DEFAULT_HUB_PORT,
+		);
+	});
+
+	it("treats --conditions=development as a development build", () => {
+		expect(
+			resolveDefaultHubPort({
+				env: {},
+				execArgv: ["--conditions=development"],
+			}),
+		).toBe(DEV_HUB_PORT);
+	});
+
+	it("honors an explicit CLINE_HUB_PORT override in development", () => {
+		expect(
+			resolveDefaultHubPort({
+				env: {
+					[CLINE_BUILD_ENV_ENV]: "development",
+					CLINE_HUB_PORT: "31000",
+				},
+				execArgv: [],
+			}),
+		).toBe(31000);
+	});
+
+	it("honors an explicit CLINE_HUB_PORT override in production", () => {
+		expect(
+			resolveDefaultHubPort({
+				env: {
+					[CLINE_BUILD_ENV_ENV]: "production",
+					CLINE_HUB_PORT: "31000",
+				},
+				execArgv: [],
+			}),
+		).toBe(31000);
+	});
+
+	it("falls back to the dev default when CLINE_HUB_PORT is invalid in development", () => {
+		expect(
+			resolveDefaultHubPort({
+				env: {
+					[CLINE_BUILD_ENV_ENV]: "development",
+					CLINE_HUB_PORT: "not-a-port",
+				},
+				execArgv: [],
+			}),
+		).toBe(DEV_HUB_PORT);
+	});
+
+	it("falls back to the production default when CLINE_HUB_PORT is invalid in production", () => {
+		expect(
+			resolveDefaultHubPort({
+				env: {
+					[CLINE_BUILD_ENV_ENV]: "production",
+					CLINE_HUB_PORT: "0",
+				},
+				execArgv: [],
+			}),
+		).toBe(DEFAULT_HUB_PORT);
+	});
+});
+
+describe("resolveHubEndpointOptions", () => {
+	it("composes the dev hub port when overrides are not provided in development", () => {
+		expect(
+			resolveHubEndpointOptions(
+				{},
+				{
+					env: { [CLINE_BUILD_ENV_ENV]: "development" },
+					execArgv: [],
+				},
+			),
+		).toEqual({
+			host: "127.0.0.1",
+			port: DEV_HUB_PORT,
+			pathname: "/hub",
+		});
+	});
+
+	it("respects explicit port overrides regardless of build env", () => {
+		expect(
+			resolveHubEndpointOptions(
+				{ port: 40000 },
+				{
+					env: { [CLINE_BUILD_ENV_ENV]: "development" },
+					execArgv: [],
+				},
+			).port,
+		).toBe(40000);
+	});
+});