codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/core/src/auth/server.test.ts

@@ -0,0 +1,319 @@
+import http from "node:http";
+import net from "node:net";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { startLocalOAuthServer } from "./server";
+
+const socketBindingSupported = await (async () => {
+	try {
+		const srv = net.createServer();
+		await new Promise<void>((resolve, reject) => {
+			srv.listen(0, "127.0.0.1", () => resolve());
+			srv.once("error", reject);
+		});
+		await new Promise<void>((resolve, reject) =>
+			srv.close((err) => (err ? reject(err) : resolve())),
+		);
+		return true;
+	} catch {
+		return false;
+	}
+})();
+const socketIt = socketBindingSupported ? it : it.skip;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Bind to port 0 to let the OS pick a free port, then release it. */
+function getFreePort(): Promise<number> {
+	return new Promise((resolve, reject) => {
+		const srv = net.createServer();
+		srv.listen(0, "127.0.0.1", () => {
+			const addr = srv.address() as net.AddressInfo;
+			srv.close(() => resolve(addr.port));
+		});
+		srv.on("error", reject);
+	});
+}
+
+/** Occupy a port so the OAuth server cannot bind to it. */
+function occupyPort(port: number): Promise<http.Server> {
+	return new Promise((resolve, reject) => {
+		const srv = http.createServer();
+		srv.listen(port, "127.0.0.1", () => resolve(srv));
+		srv.on("error", reject);
+	});
+}
+
+/** Close an http.Server, resolving when the socket is gone. */
+function closeServer(srv: http.Server): Promise<void> {
+	return new Promise((resolve, reject) =>
+		srv.close((err) => (err ? reject(err) : resolve())),
+	);
+}
+
+/** Make a GET request and return status + body. */
+function get(url: string): Promise<{ status: number; body: string }> {
+	return new Promise((resolve, reject) => {
+		http
+			.get(url, (res) => {
+				let body = "";
+				res.on("data", (chunk: Buffer) => {
+					body += chunk.toString();
+				});
+				res.on("end", () => resolve({ status: res.statusCode ?? 0, body }));
+			})
+			.on("error", reject);
+	});
+}
+
+/** Flush microtasks + a short macro-task delay for fire-and-forget promises. */
+function flushAsync(): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, 20));
+}
+
+// ---------------------------------------------------------------------------
+// onListening
+// ---------------------------------------------------------------------------
+
+describe("auth/server startLocalOAuthServer — onListening", () => {
+	socketIt(
+		"is called with host, port, and callbackUrl when the server binds",
+		async () => {
+			const port = await getFreePort();
+			const onListening = vi.fn();
+
+			const server = await startLocalOAuthServer({
+				ports: [port],
+				callbackPath: "/callback",
+				onListening,
+			});
+
+			expect(onListening).toHaveBeenCalledOnce();
+			expect(onListening).toHaveBeenCalledWith({
+				host: "127.0.0.1",
+				port,
+				callbackUrl: `http://127.0.0.1:${port}/callback`,
+			});
+
+			server.close();
+		},
+	);
+
+	socketIt("is not called when no port can be bound", async () => {
+		const port = await getFreePort();
+		const blocker = await occupyPort(port);
+		const onListening = vi.fn();
+
+		await startLocalOAuthServer({
+			ports: [port],
+			callbackPath: "/callback",
+			onListening,
+		});
+
+		expect(onListening).not.toHaveBeenCalled();
+
+		await closeServer(blocker);
+	});
+
+	socketIt(
+		"fires for the first available port and skips occupied ones",
+		async () => {
+			const [port1, port2] = await Promise.all([getFreePort(), getFreePort()]);
+			const blocker = await occupyPort(port1);
+			const onListening = vi.fn();
+
+			const server = await startLocalOAuthServer({
+				ports: [port1, port2],
+				callbackPath: "/cb",
+				onListening,
+			});
+
+			expect(onListening).toHaveBeenCalledOnce();
+			expect(onListening).toHaveBeenCalledWith(
+				expect.objectContaining({ port: port2 }),
+			);
+
+			server.close();
+			await closeServer(blocker);
+		},
+	);
+
+	socketIt("swallows errors thrown by the onListening callback", async () => {
+		const port = await getFreePort();
+		const onListening = vi
+			.fn()
+			.mockReturnValue(Promise.reject(new Error("listening boom")));
+
+		const server = await startLocalOAuthServer({
+			ports: [port],
+			callbackPath: "/callback",
+			onListening,
+		});
+
+		await flushAsync();
+		expect(onListening).toHaveBeenCalledOnce();
+
+		server.close();
+	});
+});
+
+// ---------------------------------------------------------------------------
+// onClose
+// ---------------------------------------------------------------------------
+
+describe("auth/server startLocalOAuthServer — onClose", () => {
+	socketIt("is called with host and port when close() is invoked", async () => {
+		const port = await getFreePort();
+		const onClose = vi.fn();
+
+		const server = await startLocalOAuthServer({
+			ports: [port],
+			callbackPath: "/callback",
+			onClose,
+		});
+
+		server.close();
+
+		expect(onClose).toHaveBeenCalledOnce();
+		expect(onClose).toHaveBeenCalledWith({ host: "127.0.0.1", port });
+	});
+
+	socketIt(
+		"is called with host and port when cancelWait() is invoked",
+		async () => {
+			const port = await getFreePort();
+			const onClose = vi.fn();
+
+			const server = await startLocalOAuthServer({
+				ports: [port],
+				callbackPath: "/callback",
+				onClose,
+			});
+
+			server.cancelWait();
+
+			expect(onClose).toHaveBeenCalledOnce();
+			expect(onClose).toHaveBeenCalledWith({ host: "127.0.0.1", port });
+		},
+	);
+
+	socketIt("is called after a successful OAuth callback request", async () => {
+		const port = await getFreePort();
+		const onClose = vi.fn();
+
+		const server = await startLocalOAuthServer({
+			ports: [port],
+			callbackPath: "/callback",
+			onClose,
+		});
+
+		const waitPromise = server.waitForCallback();
+		const { status } = await get(
+			`http://127.0.0.1:${port}/callback?code=tok123`,
+		);
+		expect(status).toBe(200);
+
+		await waitPromise;
+
+		expect(onClose).toHaveBeenCalledOnce();
+		expect(onClose).toHaveBeenCalledWith({ host: "127.0.0.1", port });
+	});
+
+	socketIt("is not called when no port was bound", async () => {
+		const port = await getFreePort();
+		const blocker = await occupyPort(port);
+		const onClose = vi.fn();
+
+		const server = await startLocalOAuthServer({
+			ports: [port],
+			callbackPath: "/callback",
+			onClose,
+		});
+
+		server.close();
+		expect(onClose).not.toHaveBeenCalled();
+
+		await closeServer(blocker);
+	});
+
+	socketIt("swallows errors thrown by the onClose callback", async () => {
+		const port = await getFreePort();
+		const onClose = vi
+			.fn()
+			.mockReturnValue(Promise.reject(new Error("teardown failed")));
+
+		const server = await startLocalOAuthServer({
+			ports: [port],
+			callbackPath: "/callback",
+			onClose,
+		});
+
+		server.close();
+		await flushAsync();
+
+		expect(onClose).toHaveBeenCalledOnce();
+	});
+});
+
+// ---------------------------------------------------------------------------
+// onListening + onClose ordering
+// ---------------------------------------------------------------------------
+
+describe("auth/server startLocalOAuthServer — onListening + onClose together", () => {
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	socketIt(
+		"fires onListening on bind then onClose after a successful callback",
+		async () => {
+			const port = await getFreePort();
+			const order: string[] = [];
+
+			const server = await startLocalOAuthServer({
+				ports: [port],
+				callbackPath: "/cb",
+				onListening: vi.fn(() => {
+					order.push("listening");
+				}),
+				onClose: vi.fn(() => {
+					order.push("close");
+				}),
+			});
+
+			expect(order).toEqual(["listening"]);
+
+			const waitPromise = server.waitForCallback();
+			await get(`http://127.0.0.1:${port}/cb?code=mycode`);
+			const payload = await waitPromise;
+
+			expect(payload?.code).toBe("mycode");
+			expect(order).toEqual(["listening", "close"]);
+		},
+	);
+
+	socketIt(
+		"fires onListening on bind then onClose after cancelWait()",
+		async () => {
+			const port = await getFreePort();
+			const order: string[] = [];
+
+			const server = await startLocalOAuthServer({
+				ports: [port],
+				callbackPath: "/cb",
+				onListening: vi.fn(() => {
+					order.push("listening");
+				}),
+				onClose: vi.fn(() => {
+					order.push("close");
+				}),
+			});
+
+			expect(order).toEqual(["listening"]);
+
+			server.cancelWait();
+			expect(order).toEqual(["listening", "close"]);
+		},
+	);
+});

codna/agent-core/vendor/cline/sdk/packages/core/src/auth/server.ts

@@ -0,0 +1,265 @@
+export interface OAuthCallbackPayload {
+	url: URL;
+	code?: string;
+	state?: string;
+	provider?: string;
+	error?: string;
+}
+
+type Deferred<T> = {
+	promise: Promise<T>;
+	resolve: (value: T) => void;
+};
+
+function createDeferred<T>(): Deferred<T> {
+	let resolve!: (value: T) => void;
+	const promise = new Promise<T>((res) => {
+		resolve = res;
+	});
+	return { promise, resolve };
+}
+
+export interface OAuthServerListeningInfo {
+	host: string;
+	port: number;
+	callbackUrl: string;
+}
+
+export interface OAuthServerCloseInfo {
+	host: string;
+	port: number;
+}
+
+export interface LocalOAuthServerOptions {
+	host?: string;
+	ports: number[];
+	callbackPath: string;
+	timeoutMs?: number;
+	expectedState?: string;
+	successHtml?: string;
+	/**
+	 * Called when the local redirect server successfully binds to a port and is
+	 * ready to receive the OAuth callback. Hosts can use this to display a
+	 * "waiting for callback" status indicator or — in remote-development
+	 * environments like JetBrains Gateway — to forward the port from the remote
+	 * machine to the local machine where the user's browser is running.
+	 *
+	 * May be async; `startLocalOAuthServer` will **await** this callback before
+	 * returning so that any setup it performs (e.g. port-forwarding) is
+	 * guaranteed to complete before the caller opens the auth URL. Errors
+	 * thrown by this callback are swallowed — they do not prevent the OAuth
+	 * flow from proceeding.
+	 */
+	onListening?: (info: OAuthServerListeningInfo) => void | Promise<void>;
+	/**
+	 * Called when the local redirect server closes, either because the OAuth
+	 * callback was received, the flow was cancelled, or the timeout elapsed.
+	 * Hosts should use this to tear down any port-forward set up in
+	 * `onListening` and clear any "waiting for callback" status UI.
+	 *
+	 * May be async; fired after the underlying server socket is closed.
+	 */
+	onClose?: (info: OAuthServerCloseInfo) => void | Promise<void>;
+}
+
+export interface LocalOAuthServer {
+	callbackUrl: string;
+	waitForCallback: () => Promise<OAuthCallbackPayload | null>;
+	cancelWait: () => void;
+	close: () => void;
+}
+
+export async function startLocalOAuthServer(
+	options: LocalOAuthServerOptions,
+): Promise<LocalOAuthServer> {
+	const http = await import("node:http");
+
+	const host = options.host ?? "127.0.0.1";
+	const timeoutMs = options.timeoutMs ?? 5 * 60 * 1000;
+	const successHtml = options.successHtml ?? HTML_CONTENT;
+
+	const deferred = createDeferred<OAuthCallbackPayload | null>();
+	let settled = false;
+	let timeout: ReturnType<typeof setTimeout> | null = null;
+	let activeServer: import("node:http").Server | null = null;
+	let boundPort: number | null = null;
+
+	const settle = (value: OAuthCallbackPayload | null) => {
+		if (settled) return;
+		settled = true;
+		deferred.resolve(value);
+	};
+
+	const close = () => {
+		if (timeout) {
+			clearTimeout(timeout);
+			timeout = null;
+		}
+		const closingPort = boundPort;
+		boundPort = null;
+		if (activeServer) {
+			activeServer.close();
+			activeServer = null;
+		}
+		if (closingPort !== null && options.onClose) {
+			void Promise.resolve(options.onClose({ host, port: closingPort })).catch(
+				() => {},
+			);
+		}
+	};
+
+	const waitForCallback = async () => {
+		timeout = setTimeout(() => {
+			close();
+			settle(null);
+		}, timeoutMs);
+		return deferred.promise;
+	};
+
+	for (const port of options.ports) {
+		const server = http.createServer((req, res) => {
+			try {
+				const requestUrl = new URL(req.url || "", `http://${host}:${port}`);
+				if (requestUrl.pathname !== options.callbackPath) {
+					res.statusCode = 404;
+					res.end("Not found");
+					return;
+				}
+
+				const payload: OAuthCallbackPayload = {
+					url: requestUrl,
+					code: requestUrl.searchParams.get("code") ?? undefined,
+					state: requestUrl.searchParams.get("state") ?? undefined,
+					provider: requestUrl.searchParams.get("provider") ?? undefined,
+					error: requestUrl.searchParams.get("error") ?? undefined,
+				};
+
+				if (payload.error) {
+					res.statusCode = 400;
+					res.end(`Authentication failed: ${payload.error}`);
+					close();
+					settle(payload);
+					return;
+				}
+
+				if (!payload.code) {
+					res.statusCode = 400;
+					res.end("Missing authorization code");
+					return;
+				}
+
+				if (options.expectedState && payload.state !== options.expectedState) {
+					res.statusCode = 400;
+					res.end("State mismatch");
+					return;
+				}
+
+				res.statusCode = 200;
+				res.setHeader("Content-Type", "text/html; charset=utf-8");
+				res.end(successHtml);
+				close();
+				settle(payload);
+			} catch {
+				res.statusCode = 500;
+				res.end("Internal error");
+			}
+		});
+
+		const bindResult = await new Promise<{
+			bound: boolean;
+			error?: NodeJS.ErrnoException;
+		}>((resolve) => {
+			const onError = (error: NodeJS.ErrnoException) => {
+				server.off("error", onError);
+				resolve({ bound: false, error });
+			};
+
+			server.once("error", onError);
+			server.listen(port, host, () => {
+				server.off("error", onError);
+				activeServer = server;
+				resolve({ bound: true });
+			});
+		});
+
+		if (bindResult.error) {
+			if (bindResult.error.code === "EADDRINUSE") {
+				continue;
+			}
+			close();
+			throw bindResult.error;
+		}
+
+		if (bindResult.bound) {
+			boundPort = port;
+			const callbackUrl = `http://${host}:${port}${options.callbackPath}`;
+			if (options.onListening) {
+				await Promise.resolve(
+					options.onListening({ host, port, callbackUrl }),
+				).catch(() => {});
+			}
+			return {
+				callbackUrl,
+				waitForCallback,
+				cancelWait: () => {
+					close();
+					settle(null);
+				},
+				close: () => {
+					close();
+					settle(null);
+				},
+			};
+		}
+	}
+
+	return {
+		callbackUrl: "",
+		waitForCallback: async () => null,
+		cancelWait: () => {},
+		close: () => {},
+	};
+}
+
+const HTML_CONTENT = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Authentication Successful</title>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+    min-height: 100vh;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+    color: #fff;
+  }
+  .container { text-align: center; padding: 48px; max-width: 420px; }
+  .icon {
+    width: 72px; height: 72px; margin: 0 auto 24px;
+    background: linear-gradient(135deg, #10a37f 0%, #1a7f64 100%);
+    border-radius: 50%;
+    display: flex; align-items: center; justify-content: center;
+  }
+  .icon svg { width: 36px; height: 36px; stroke: #fff; stroke-width: 3; fill: none; }
+  h1 { font-size: 24px; font-weight: 600; margin-bottom: 12px; }
+  p { font-size: 15px; color: rgba(255,255,255,0.7); line-height: 1.5; }
+  .closing { margin-top: 32px; font-size: 13px; color: rgba(255,255,255,0.5); }
+</style>
+</head>
+<body>
+<div class="container">
+  <div class="icon">
+    <svg viewBox="0 0 24 24"><polyline points="20 6 9 17 4 12"></polyline></svg>
+  </div>
+  <h1>Authentication Successful</h1>
+  <p>You're now signed in. You can close this window.</p>
+  <p class="closing">This window will close automatically...</p>
+</div>
+<script>setTimeout(() => window.close(), 3000);</script>
+</body>
+</html>`;

codna/agent-core/vendor/cline/sdk/packages/core/src/auth/types.ts

@@ -0,0 +1,110 @@
+import type { ITelemetryService } from "@cline/shared";
+import type { OAuthServerCloseInfo, OAuthServerListeningInfo } from "./server";
+
+export interface OAuthPrompt {
+	message: string;
+	defaultValue?: string;
+}
+
+export interface OAuthCredentials {
+	access: string;
+	refresh: string;
+	/**
+	 * Expiration timestamp in milliseconds since epoch.
+	 */
+	expires: number;
+	/**
+	 * Optional provider-specific account identifier.
+	 */
+	accountId?: string;
+	/**
+	 * Optional email for display/telemetry.
+	 */
+	email?: string;
+	/**
+	 * Provider-specific metadata (user info, provider hint, etc).
+	 */
+	metadata?: Record<string, unknown>;
+}
+
+export interface OAuthLoginCallbacks {
+	onAuth: (info: { url: string; instructions?: string }) => void;
+	onPrompt: (prompt: OAuthPrompt) => Promise<string>;
+	onProgress?: (message: string) => void;
+	onManualCodeInput?: () => Promise<string>;
+	/**
+	 * Called when the local OAuth redirect server successfully binds to a port
+	 * and is ready to receive the browser callback. The `info` object contains
+	 * the host, the bound port number, and the full `callbackUrl`.
+	 *
+	 * Use this to:
+	 * - Show a "waiting for OAuth callback on port N" status indicator in your UI.
+	 * - Forward the port in remote-development environments (e.g. JetBrains
+	 *   Gateway) from the remote machine to the machine running the browser.
+	 *
+	 * Paired with `onServerClose` for teardown.
+	 *
+	 * Only fired when the provider uses a local callback server
+	 * (`OAuthProviderInterface.usesCallbackServer === true`).
+	 */
+	onServerListening?: (info: OAuthServerListeningInfo) => void | Promise<void>;
+	/**
+	 * Called when the local OAuth redirect server closes — either because the
+	 * callback was received, the flow was cancelled, or the timeout elapsed.
+	 *
+	 * Use this to:
+	 * - Clear any "waiting for callback" status UI shown in `onServerListening`.
+	 * - Tear down port-forwards set up in `onServerListening`.
+	 *
+	 * Only fired when the provider uses a local callback server
+	 * (`OAuthProviderInterface.usesCallbackServer === true`).
+	 */
+	onServerClose?: (info: OAuthServerCloseInfo) => void | Promise<void>;
+}
+
+export interface OAuthProviderInterface {
+	id: string;
+	name: string;
+	usesCallbackServer: boolean;
+	login(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials>;
+	refreshToken(credentials: OAuthCredentials): Promise<OAuthCredentials>;
+	getApiKey(credentials: OAuthCredentials): string;
+}
+
+export type OcaMode = "internal" | "external";
+
+export interface OcaOAuthEnvironmentConfig {
+	clientId: string;
+	idcsUrl: string;
+	scopes: string;
+	baseUrl: string;
+}
+
+export interface OcaOAuthConfig {
+	internal: OcaOAuthEnvironmentConfig;
+	external: OcaOAuthEnvironmentConfig;
+}
+
+export interface OcaClientMetadata {
+	client?: string;
+	clientVersion?: string;
+	clientIde?: string;
+	clientIdeVersion?: string;
+}
+
+export interface OcaOAuthProviderOptions {
+	config?: Partial<OcaOAuthConfig>;
+	mode?: OcaMode | (() => OcaMode);
+	callbackPath?: string;
+	callbackPorts?: number[];
+	requestTimeoutMs?: number;
+	refreshBufferMs?: number;
+	retryableTokenGraceMs?: number;
+	telemetry?: ITelemetryService;
+}
+
+export interface OcaTokenResolution {
+	forceRefresh?: boolean;
+	refreshBufferMs?: number;
+	retryableTokenGraceMs?: number;
+}