codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/core/src/hub/server/browser-websocket.test.ts

@@ -0,0 +1,173 @@
+import type { HubReplyEnvelope } from "@cline/shared";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { BrowserWebSocketHubAdapter } from "./browser-websocket";
+
+function createSocket() {
+	const messageListeners = new Set<(event: { data: string }) => void>();
+	const closeListeners = new Set<() => void>();
+	return {
+		sent: [] as string[],
+		send(data: string) {
+			this.sent.push(data);
+		},
+		addEventListener(
+			type: "message" | "close",
+			listener: ((event: { data: string }) => void) | (() => void),
+		) {
+			if (type === "message") {
+				messageListeners.add(listener as (event: { data: string }) => void);
+				return;
+			}
+			closeListeners.add(listener as () => void);
+		},
+		removeEventListener(
+			type: "message" | "close",
+			listener: ((event: { data: string }) => void) | (() => void),
+		) {
+			if (type === "message") {
+				messageListeners.delete(listener as (event: { data: string }) => void);
+				return;
+			}
+			closeListeners.delete(listener as () => void);
+		},
+		emitMessage(data: string) {
+			for (const listener of messageListeners) {
+				void listener({ data });
+			}
+		},
+		emitClose() {
+			for (const listener of closeListeners) {
+				listener();
+			}
+		},
+	};
+}
+
+describe("BrowserWebSocketHubAdapter", () => {
+	afterEach(() => {
+		vi.useRealTimers();
+		vi.restoreAllMocks();
+	});
+
+	it("ignores malformed websocket frames instead of throwing", async () => {
+		const transport = {
+			command: vi.fn(),
+			subscribe: vi.fn(),
+		};
+		const socket = createSocket();
+		const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+		try {
+			const adapter = new BrowserWebSocketHubAdapter(transport);
+			adapter.attach(socket);
+
+			await expect(async () => {
+				socket.emitMessage("{bad json");
+				await Promise.resolve();
+			}).not.toThrow();
+
+			expect(transport.command).not.toHaveBeenCalled();
+			expect(socket.sent).toHaveLength(0);
+			expect(errorSpy).toHaveBeenCalledWith(
+				expect.stringContaining(
+					'"message":"rejected malformed websocket frame"',
+				),
+			);
+		} finally {
+			errorSpy.mockRestore();
+		}
+	});
+
+	it("keeps run.start open past the default command timeout", async () => {
+		vi.useFakeTimers();
+		vi.spyOn(console, "error").mockImplementation(() => {});
+		let resolveCommand: ((reply: HubReplyEnvelope) => void) | undefined;
+		const transport = {
+			command: vi.fn(
+				() =>
+					new Promise<HubReplyEnvelope>((resolve) => {
+						resolveCommand = resolve;
+					}),
+			),
+			subscribe: vi.fn(),
+		};
+		const socket = createSocket();
+		const adapter = new BrowserWebSocketHubAdapter(transport);
+		adapter.attach(socket);
+
+		socket.emitMessage(
+			JSON.stringify({
+				kind: "command",
+				envelope: {
+					version: "v1",
+					command: "run.start",
+					requestId: "req-run",
+					clientId: "client-1",
+					sessionId: "session-1",
+					payload: { input: "hello" },
+				},
+			}),
+		);
+
+		await vi.advanceTimersByTimeAsync(30_001);
+		expect(socket.sent).toHaveLength(0);
+
+		resolveCommand?.({
+			version: "v1",
+			requestId: "req-run",
+			ok: true,
+			payload: { result: { finishReason: "completed" } },
+		});
+		await Promise.resolve();
+
+		expect(socket.sent.map((entry) => JSON.parse(entry))).toContainEqual({
+			kind: "reply",
+			envelope: {
+				version: "v1",
+				requestId: "req-run",
+				ok: true,
+				payload: { result: { finishReason: "completed" } },
+			},
+		});
+	});
+
+	it("applies the default command timeout to fast commands", async () => {
+		vi.useFakeTimers();
+		vi.spyOn(console, "error").mockImplementation(() => {});
+		const transport = {
+			command: vi.fn(() => new Promise<HubReplyEnvelope>(() => {})),
+			subscribe: vi.fn(),
+		};
+		const socket = createSocket();
+		const adapter = new BrowserWebSocketHubAdapter(transport);
+		adapter.attach(socket);
+
+		socket.emitMessage(
+			JSON.stringify({
+				kind: "command",
+				envelope: {
+					version: "v1",
+					command: "client.list",
+					requestId: "req-list",
+					clientId: "client-1",
+				},
+			}),
+		);
+
+		await vi.advanceTimersByTimeAsync(30_001);
+
+		expect(socket.sent.map((entry) => JSON.parse(entry))).toContainEqual({
+			kind: "reply",
+			envelope: {
+				version: "v1",
+				requestId: "req-list",
+				ok: false,
+				error: {
+					code: "hub_command_timeout",
+					message:
+						"Hub command client.list did not complete within 30000ms. Check hub-daemon.log for command.start/command.slow logs with requestId req-list.",
+				},
+			},
+		});
+	});
+});

codna/agent-core/vendor/cline/sdk/packages/core/src/hub/server/browser-websocket.ts

@@ -0,0 +1,295 @@
+import type {
+	HubClientRegistration,
+	HubEventEnvelope,
+	HubReplyEnvelope,
+	HubTransportFrame,
+	ITelemetryService,
+} from "@cline/shared";
+import {
+	captureSdkError,
+	HUB_COMMAND_SLOW_LOG_MS,
+	resolveHubCommandTimeoutMs,
+	safeJsonParse,
+} from "@cline/shared";
+import type { HubCommandTransport } from "./command-transport";
+import { logHubMessage } from "./hub-server-logging";
+
+type HubCommandFrame = HubTransportFrame & { kind: "command" };
+
+export interface BrowserHubSocketLike {
+	send(data: string): void;
+	addEventListener(
+		type: "message",
+		listener: (event: { data: string }) => void,
+	): void;
+	addEventListener(type: "close", listener: () => void): void;
+	removeEventListener(
+		type: "message",
+		listener: (event: { data: string }) => void,
+	): void;
+	removeEventListener(type: "close", listener: () => void): void;
+}
+
+function commandLogContext(frame: HubCommandFrame) {
+	return {
+		command: frame.envelope.command,
+		requestId: frame.envelope.requestId,
+		clientId: frame.envelope.clientId,
+		sessionId: frame.envelope.sessionId,
+	};
+}
+
+function commandErrorReply(
+	frame: HubCommandFrame,
+	code: string,
+	message: string,
+): HubReplyEnvelope {
+	return {
+		version: frame.envelope.version,
+		requestId: frame.envelope.requestId,
+		ok: false,
+		error: { code, message },
+	};
+}
+
+export class BrowserWebSocketHubAdapter {
+	constructor(
+		private readonly transport: HubCommandTransport,
+		private readonly telemetry?: ITelemetryService,
+	) {}
+
+	attach(socket: BrowserHubSocketLike): () => void {
+		const subscriptions = new Map<string, () => void>();
+		const registeredClientIds = new Set<string>();
+		let closed = false;
+
+		const sendFrame = (frame: HubTransportFrame): void => {
+			try {
+				socket.send(JSON.stringify(frame));
+			} catch (error) {
+				console.error(
+					`[hub] failed to send websocket frame: ${
+						error instanceof Error
+							? error.stack || error.message
+							: String(error)
+					}`,
+				);
+			}
+		};
+
+		const onEvent = (envelope: HubEventEnvelope): void => {
+			sendFrame({ kind: "event", envelope });
+		};
+
+		const onMessage = async (event: { data: string }): Promise<void> => {
+			try {
+				const frame = JSON.parse(event.data) as HubTransportFrame;
+				switch (frame.kind) {
+					case "command": {
+						const startedAt = performance.now();
+						let settled = false;
+						const context = commandLogContext(frame);
+						logHubMessage("info", "command.start", context);
+						const slowTimer = setTimeout(() => {
+							if (settled) return;
+							logHubMessage("warn", "command.slow", {
+								...context,
+								elapsedMs: Math.round(performance.now() - startedAt),
+							});
+						}, HUB_COMMAND_SLOW_LOG_MS);
+						const commandPromise = this.transport.command(frame.envelope);
+						commandPromise.then(
+							(lateReply) => {
+								if (!settled) return;
+								logHubMessage(
+									lateReply.ok ? "warn" : "error",
+									"command.late_end",
+									{
+										...context,
+										elapsedMs: Math.round(performance.now() - startedAt),
+										ok: lateReply.ok,
+										errorCode: lateReply.error?.code,
+										errorMessage: lateReply.error?.message,
+									},
+								);
+							},
+							(error) => {
+								if (!settled) return;
+								logHubMessage("error", "command.late_error", {
+									...context,
+									elapsedMs: Math.round(performance.now() - startedAt),
+									error,
+								});
+							},
+						);
+						let timedOut = false;
+						let timeoutTimer: ReturnType<typeof setTimeout> | undefined;
+						let reply: HubReplyEnvelope;
+						const timeoutMs = resolveHubCommandTimeoutMs(
+							frame.envelope.command,
+							frame.envelope.timeoutMs,
+						);
+						try {
+							reply =
+								timeoutMs === null
+									? await commandPromise
+									: await Promise.race([
+											commandPromise,
+											new Promise<HubReplyEnvelope>((resolve) => {
+												timeoutTimer = setTimeout(() => {
+													timedOut = true;
+													captureSdkError(this.telemetry, {
+														component: "core",
+														operation: "hub.command_timeout",
+														error: new Error(
+															`Hub command ${frame.envelope.command} did not complete within ${timeoutMs}ms.`,
+														),
+														severity: "error",
+														handled: true,
+														context: {
+															...context,
+															timeoutMs,
+														},
+													});
+													resolve(
+														commandErrorReply(
+															frame,
+															"hub_command_timeout",
+															`Hub command ${frame.envelope.command} did not complete within ${timeoutMs}ms. Check hub-daemon.log for command.start/command.slow logs with requestId ${frame.envelope.requestId}.`,
+														),
+													);
+												}, timeoutMs);
+											}),
+										]);
+						} catch (error) {
+							clearTimeout(slowTimer);
+							if (timeoutTimer) clearTimeout(timeoutTimer);
+							throw error;
+						}
+						settled = timedOut;
+						clearTimeout(slowTimer);
+						if (timeoutTimer) clearTimeout(timeoutTimer);
+						const durationMs = Math.round(performance.now() - startedAt);
+						if (timedOut) {
+							logHubMessage("error", "command.timeout", {
+								...context,
+								durationMs,
+								timeoutMs,
+							});
+						} else {
+							logHubMessage(reply.ok ? "info" : "warn", "command.end", {
+								...context,
+								durationMs,
+								ok: reply.ok,
+								errorCode: reply.error?.code,
+								errorMessage: reply.error?.message,
+							});
+						}
+						if (frame.envelope.command === "client.register" && reply.ok) {
+							const registration = (frame.envelope.payload ??
+								{}) as unknown as HubClientRegistration;
+							const clientId =
+								registration.clientId?.trim() ||
+								frame.envelope.clientId?.trim();
+							if (clientId) {
+								registeredClientIds.add(clientId);
+							}
+						} else if (
+							frame.envelope.command === "client.unregister" &&
+							reply.ok
+						) {
+							const clientId = frame.envelope.clientId?.trim();
+							if (clientId) {
+								registeredClientIds.delete(clientId);
+							}
+						}
+						sendFrame({
+							kind: "reply",
+							envelope: reply satisfies HubReplyEnvelope,
+						});
+						break;
+					}
+					case "stream.subscribe": {
+						const key = `${frame.clientId}:${frame.sessionId ?? "*"}`;
+						if (subscriptions.has(key)) {
+							break;
+						}
+						const unsubscribe = await this.transport.subscribe(
+							frame.clientId,
+							onEvent,
+							{ sessionId: frame.sessionId },
+						);
+						subscriptions.set(key, unsubscribe);
+						break;
+					}
+					case "stream.unsubscribe": {
+						const key = `${frame.clientId}:${frame.sessionId ?? "*"}`;
+						subscriptions.get(key)?.();
+						subscriptions.delete(key);
+						break;
+					}
+					case "reply":
+					case "event":
+						break;
+				}
+			} catch (error) {
+				const parsed =
+					typeof event.data === "string"
+						? safeJsonParse<HubTransportFrame>(event.data)
+						: undefined;
+				if (!parsed || parsed.kind !== "command") {
+					logHubMessage("error", "rejected malformed websocket frame", {
+						error,
+					});
+					return;
+				}
+				logHubMessage("error", "command.error", {
+					...commandLogContext(parsed),
+					error,
+				});
+				captureSdkError(this.telemetry, {
+					component: "core",
+					operation: "hub.websocket_command",
+					error,
+					severity: "error",
+					handled: true,
+					context: commandLogContext(parsed),
+				});
+				sendFrame({
+					kind: "reply",
+					envelope: commandErrorReply(
+						parsed,
+						"command_failed",
+						error instanceof Error ? error.message : "Unknown hub error",
+					),
+				});
+			}
+		};
+
+		const onClose = (): void => {
+			if (closed) {
+				return;
+			}
+			closed = true;
+			for (const unsubscribe of subscriptions.values()) {
+				unsubscribe();
+			}
+			subscriptions.clear();
+			for (const clientId of registeredClientIds) {
+				void this.transport.command({
+					version: "v1",
+					command: "client.unregister",
+					clientId,
+				});
+			}
+			registeredClientIds.clear();
+			socket.removeEventListener("message", onMessage);
+			socket.removeEventListener("close", onClose);
+		};
+
+		socket.addEventListener("message", onMessage);
+		socket.addEventListener("close", onClose);
+
+		return onClose;
+	}
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/hub/server/command-transport.ts

@@ -0,0 +1,14 @@
+import type {
+	HubCommandEnvelope,
+	HubEventEnvelope,
+	HubReplyEnvelope,
+} from "@cline/shared";
+
+export interface HubCommandTransport {
+	command(envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+	subscribe(
+		clientId: string,
+		listener: (event: HubEventEnvelope) => void,
+		options?: { sessionId?: string },
+	): Promise<() => void> | (() => void);
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/hub/server/fetch-wiring.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, it, vi } from "vitest";
+
+const localRuntimeHostMock = vi.hoisted(() =>
+	vi.fn().mockImplementation(function (this: unknown, _options: unknown) {
+		const instance = this as Record<string, unknown>;
+		instance.subscribe = vi.fn(() => () => {});
+		instance.dispose = vi.fn(async () => {});
+		instance.start = vi.fn();
+		instance.send = vi.fn();
+		instance.abort = vi.fn();
+		instance.stop = vi.fn();
+		instance.runtimeAddress = undefined;
+	}),
+);
+
+vi.mock("../../runtime/host/local-runtime-host", () => ({
+	LocalRuntimeHost: localRuntimeHostMock,
+}));
+
+describe("hub server fetch wiring", () => {
+	it("forwards HubWebSocketServerOptions.fetch into the internal LocalRuntimeHost", async () => {
+		localRuntimeHostMock.mockClear();
+		const { HubServerTransport } = (await import(".")) as unknown as {
+			HubServerTransport: new (options: unknown) => unknown;
+		};
+
+		const customFetch = (async () => new Response()) as unknown as typeof fetch;
+
+		new HubServerTransport({
+			runtimeHandlers: {
+				startSession: vi.fn(),
+				sendSession: vi.fn(),
+				abortSession: vi.fn(),
+				stopSession: vi.fn(),
+			},
+			fetch: customFetch,
+		});
+
+		expect(localRuntimeHostMock).toHaveBeenCalledTimes(1);
+		const constructorArgs = localRuntimeHostMock.mock.calls[0]?.[0] as {
+			fetch?: typeof fetch;
+		};
+		expect(constructorArgs.fetch).toBe(customFetch);
+	});
+
+	it("does not construct a default LocalRuntimeHost when sessionHost is supplied", async () => {
+		localRuntimeHostMock.mockClear();
+		const { HubServerTransport } = (await import(".")) as unknown as {
+			HubServerTransport: new (options: unknown) => unknown;
+		};
+
+		const suppliedHost = {
+			subscribe: vi.fn(() => () => {}),
+			dispose: vi.fn(async () => {}),
+			runtimeAddress: undefined,
+		};
+
+		new HubServerTransport({
+			sessionHost: suppliedHost,
+			runtimeHandlers: {
+				startSession: vi.fn(),
+				sendSession: vi.fn(),
+				abortSession: vi.fn(),
+				stopSession: vi.fn(),
+			},
+			fetch: (async () => new Response()) as unknown as typeof fetch,
+		});
+
+		expect(localRuntimeHostMock).not.toHaveBeenCalled();
+	});
+
+	it("forwards createLocalHubScheduleRuntimeHandlers fetch into its internal LocalRuntimeHost", async () => {
+		localRuntimeHostMock.mockClear();
+		const { createLocalHubScheduleRuntimeHandlers } = await import(
+			"../daemon/runtime-handlers"
+		);
+
+		const customFetch = (async () => new Response()) as unknown as typeof fetch;
+		createLocalHubScheduleRuntimeHandlers({ fetch: customFetch });
+
+		expect(localRuntimeHostMock).toHaveBeenCalledTimes(1);
+		const constructorArgs = localRuntimeHostMock.mock.calls[0]?.[0] as {
+			fetch?: typeof fetch;
+		};
+		expect(constructorArgs.fetch).toBe(customFetch);
+	});
+
+	it("leaves fetch undefined when createLocalHubScheduleRuntimeHandlers is called without one", async () => {
+		localRuntimeHostMock.mockClear();
+		const { createLocalHubScheduleRuntimeHandlers } = await import(
+			"../daemon/runtime-handlers"
+		);
+
+		createLocalHubScheduleRuntimeHandlers();
+
+		expect(localRuntimeHostMock).toHaveBeenCalledTimes(1);
+		const constructorArgs = localRuntimeHostMock.mock.calls[0]?.[0] as {
+			fetch?: typeof fetch;
+		};
+		expect(constructorArgs.fetch).toBeUndefined();
+	});
+});

codna/agent-core/vendor/cline/sdk/packages/core/src/hub/server/handlers/approval-handlers.ts

@@ -0,0 +1,133 @@
+import type {
+	HubCommandEnvelope,
+	HubReplyEnvelope,
+	ToolApprovalRequest,
+} from "@cline/shared";
+import { createSessionId } from "@cline/shared";
+import { errorReply, type HubTransportContext, okReply } from "./context";
+
+export async function requestToolApproval(
+	ctx: HubTransportContext,
+	request: ToolApprovalRequest,
+): Promise<{ approved: boolean; reason?: string }> {
+	const approvalId = createSessionId("approval_");
+	const sessionId = request.sessionId;
+	const state = ctx.sessionState.get(sessionId);
+	if (state?.interactive === false) {
+		return {
+			approved: false,
+			reason:
+				"Tool approval requires an interactive session, but this session is non-interactive.",
+		};
+	}
+	return await new Promise((resolve) => {
+		ctx.pendingApprovals.set(approvalId, {
+			sessionId,
+			resolve,
+		});
+		ctx.publish(
+			ctx.buildEvent(
+				"approval.requested",
+				{
+					approvalId,
+					sessionId: request.sessionId,
+					agentId: request.agentId,
+					conversationId: request.conversationId,
+					iteration: request.iteration,
+					toolCallId: request.toolCallId,
+					toolName: request.toolName,
+					inputJson: JSON.stringify(request.input ?? null),
+					policy: request.policy,
+				},
+				sessionId,
+			),
+		);
+	});
+}
+
+export function resolvePendingApproval(
+	ctx: HubTransportContext,
+	approvalId: string,
+	result: { approved: boolean; reason?: string },
+): { sessionId: string } | undefined {
+	const pending = ctx.pendingApprovals.get(approvalId);
+	if (!pending) {
+		return undefined;
+	}
+	ctx.pendingApprovals.delete(approvalId);
+	pending.resolve(result);
+	return { sessionId: pending.sessionId };
+}
+
+export function cancelPendingApprovals(
+	ctx: HubTransportContext,
+	filter: (approval: { approvalId: string; sessionId: string }) => boolean,
+	reason: string,
+): number {
+	let cancelled = 0;
+	for (const [approvalId, pending] of [...ctx.pendingApprovals.entries()]) {
+		if (!filter({ approvalId, sessionId: pending.sessionId })) {
+			continue;
+		}
+		ctx.pendingApprovals.delete(approvalId);
+		pending.resolve({ approved: false, reason });
+		ctx.publish(
+			ctx.buildEvent(
+				"approval.resolved",
+				{ approvalId, approved: false, cancelled: true, reason },
+				pending.sessionId,
+			),
+		);
+		cancelled += 1;
+	}
+	return cancelled;
+}
+
+export async function handleApprovalRespond(
+	ctx: HubTransportContext,
+	envelope: HubCommandEnvelope,
+): Promise<HubReplyEnvelope> {
+	const approvalId =
+		typeof envelope.payload?.approvalId === "string"
+			? envelope.payload.approvalId.trim()
+			: "";
+	const pending = ctx.pendingApprovals.get(approvalId);
+	if (!pending) {
+		return errorReply(
+			envelope,
+			"approval_not_found",
+			`Unknown approval: ${approvalId}`,
+		);
+	}
+	const reason =
+		typeof envelope.payload?.reason === "string"
+			? envelope.payload.reason
+			: envelope.payload?.payload &&
+					typeof envelope.payload.payload === "object" &&
+					!Array.isArray(envelope.payload.payload) &&
+					typeof (envelope.payload.payload as Record<string, unknown>)
+						.reason === "string"
+				? ((envelope.payload.payload as Record<string, unknown>)
+						.reason as string)
+				: undefined;
+	const approved = envelope.payload?.approved === true;
+	const resolved = resolvePendingApproval(ctx, approvalId, {
+		approved,
+		reason,
+	});
+	if (!resolved) {
+		return errorReply(
+			envelope,
+			"approval_not_found",
+			`Unknown approval: ${approvalId}`,
+		);
+	}
+	ctx.publish(
+		ctx.buildEvent(
+			"approval.resolved",
+			{ approvalId, approved, reason },
+			resolved.sessionId,
+		),
+	);
+	return okReply(envelope, { approvalId, approved });
+}