codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/algenta/server/contracts.ts

@@ -0,0 +1,254 @@
+import { EXPLORATION_TOOLS, type AgentTaskKind } from "../task-policy";
+
+export type SessionChannel = "api" | "cli" | "mcp" | "github" | "test";
+
+export type ApprovalProfile =
+	| "repository_review"
+	| "repository_fix_gated"
+	| "local_validation"
+	| "ci_controlled_repo_automation";
+
+export type TerminalState =
+	| "runtime_invalid"
+	| "policy_denied"
+	| "plugin_evidence_missing"
+	| "engine_evidence_missing"
+	| "apply_blocked"
+	| "aborted"
+	| "stopped"
+	| "failed"
+	| "succeeded";
+
+export type SessionLifecycleState =
+	| "created"
+	| "started"
+	| "running"
+	| "completed"
+	| "failed"
+	| "aborted"
+	| "stopped"
+	| "deleted";
+
+export type ToolPolicy = { enabled?: boolean; autoApprove?: boolean };
+
+export interface CanonicalEvent {
+	schema_version: "cline-session-event/v1";
+	event_id: string;
+	event_index: number;
+	session_id: string;
+	observed_at: string;
+	event_type: string;
+	payload: Record<string, unknown>;
+}
+
+export interface ApprovalEventRecord {
+	tool: string;
+	decision: "approved" | "denied";
+	reason: string;
+	auto_approved: boolean;
+}
+
+export interface ToolCallEvidence {
+	count: number;
+	first_event_id: string | null;
+	last_event_id: string | null;
+	statuses: string[];
+}
+
+export interface GovernHookEvidence {
+	status: "disabled" | "unobserved" | "observed";
+	verdict?: string;
+	event_id?: string;
+	policy_version?: string;
+}
+
+export interface SessionArtifacts {
+	runtime_manifest?: string;
+	messages?: string;
+	usage?: string;
+	events_ndjson?: string;
+	tool_calls?: string;
+	approvals?: string;
+	gate?: string;
+}
+
+export interface SessionAuthorization {
+	caller: string;
+	workflow_identity: string | null;
+	repository_allowed: boolean;
+	branch_allowed: boolean;
+}
+
+export interface SessionEngineConfig {
+	enabled: boolean;
+	url?: string;
+	repositoryId?: string;
+	snapshotId?: string;
+	apiKey?: string;
+	requiredTools: string[];
+	expectedCalls: string[];
+	failOnZeroCalls: boolean;
+	requireGovernHook: boolean;
+}
+
+export interface SessionPolicy {
+	profile: ApprovalProfile;
+	requestedPolicy: Record<string, unknown>;
+	effectivePolicy: Record<string, unknown>;
+	toolPolicies: Record<string, ToolPolicy>;
+	allowedWriteScope: string[];
+	disallowedWriteScope: string[];
+	wildcardAutoApproveUsed: boolean;
+}
+
+export interface SessionRecord {
+	sessionId: string;
+	agentRunId: string;
+	owner: string;
+	channel: SessionChannel;
+	repositoryScope: string;
+	approvalProfile: ApprovalProfile;
+	idempotencyKey: string | null;
+	replayOfRunId: string | null;
+	workingDir: string;
+	prompt: string;
+	injectedContext: string;
+	taskKind?: AgentTaskKind;
+	provider?: string;
+	model?: string;
+	// B10 PR11b: per-tenant LLM provider key (server-derived from the authenticated org) + the
+	// fail-closed flag. Never returned by toPublicSession (key material stays server-side).
+	providerApiKey?: string;
+	requireProviderApiKey?: boolean;
+	baseUrl?: string;
+	headers?: Record<string, string>;
+	toolProfile?: string;
+	suppressExploration: boolean;
+	enableSpawnAgent: boolean;
+	enableAgentTeams: boolean;
+	limits?: { maxIterations?: number; timeoutMs?: number };
+	engine: SessionEngineConfig;
+	policy: SessionPolicy;
+	authorization: SessionAuthorization;
+	state: SessionLifecycleState;
+	createdAt: string;
+	updatedAt: string;
+	events: CanonicalEvent[];
+	artifacts: SessionArtifacts;
+	secondaryReasons: string[];
+	terminalState: TerminalState | null;
+	approvalEvents: ApprovalEventRecord[];
+	cline?: import("@cline/core").ClineCore;
+	unsubscribe?: () => void;
+	startedSession?: {
+		sessionId: string;
+		manifestPath: string;
+		messagesPath: string;
+	};
+	lastResult?: Record<string, unknown>;
+	lastUsage?: Record<string, number>;
+	lastMessages?: unknown[];
+	manifestError?: string;
+}
+
+export interface RuntimeIdentity {
+	bootId: string;
+	entrypoint: string;
+}
+
+export const HOST = "127.0.0.1";
+
+export const DEFAULT_CHANNEL: SessionChannel = "api";
+
+export const DEFAULT_APPROVAL_PROFILE: ApprovalProfile = "repository_fix_gated";
+
+export const DEFAULT_APPROVAL_PROFILES: Record<
+	ApprovalProfile,
+	{
+		allowedTools: string[];
+		allowedWriteScope: string[];
+		allowSpawnAgent: boolean;
+		allowAgentTeams: boolean;
+	}
+> = {
+	repository_review: {
+		allowedTools: [
+			"read_files",
+			"search_codebase",
+			"fetch_web_content",
+			"skills",
+			"ask_question",
+		],
+		allowedWriteScope: [],
+		allowSpawnAgent: false,
+		allowAgentTeams: false,
+	},
+	repository_fix_gated: {
+		allowedTools: [
+			"read_files",
+			"search_codebase",
+			"fetch_web_content",
+			"editor",
+			"apply_patch",
+			"skills",
+			"localize",
+			"graph_query",
+			"simulate_patch",
+		],
+		allowedWriteScope: ["patch_artifact", "bot_branch"],
+		allowSpawnAgent: false,
+		allowAgentTeams: false,
+	},
+	local_validation: {
+		allowedTools: [
+			"read_files",
+			"search_codebase",
+			"fetch_web_content",
+			"run_commands",
+			"editor",
+			"apply_patch",
+			"skills",
+			"localize",
+			"graph_query",
+			"simulate_patch",
+		],
+		allowedWriteScope: ["patch_artifact", "working_tree"],
+		allowSpawnAgent: false,
+		allowAgentTeams: false,
+	},
+	ci_controlled_repo_automation: {
+		allowedTools: [
+			"read_files",
+			"search_codebase",
+			"fetch_web_content",
+			"run_commands",
+			"editor",
+			"apply_patch",
+			"skills",
+			"localize",
+			"graph_query",
+			"simulate_patch",
+			"spawn_agent",
+		],
+		allowedWriteScope: [
+			"patch_artifact",
+			"bot_branch",
+			"pr_comment",
+			"check_summary",
+		],
+		allowSpawnAgent: true,
+		allowAgentTeams: true,
+	},
+};
+
+export const TERMINAL_PRECEDENCE: TerminalState[] = [
+	"runtime_invalid",
+	"policy_denied",
+	"plugin_evidence_missing",
+	"engine_evidence_missing",
+	"apply_blocked",
+	"aborted",
+	"stopped",
+	"failed",
+	"succeeded",
+];

codna/agent-core/vendor/cline/algenta/server/execution.ts

@@ -0,0 +1,284 @@
+import { ClineCore } from "@cline/core";
+import {
+	buildStartConfig,
+	type RunAgentArgs,
+	resolveProviderConfig,
+} from "../adapter";
+import type { ProofRuntimeContext } from "../proofs";
+import {
+	approvalEventsForTurn,
+	deriveToolCallEvidence,
+	finalizeSessionArtifacts,
+	onCoreSessionEvent,
+} from "./artifacts";
+import type { RuntimeIdentity, SessionRecord } from "./contracts";
+import type { ServerState } from "./state";
+import { type EngineContext, engineContext } from "../tools";
+import {
+	appendSessionEvent,
+	optionalString,
+	updateSessionTimestamp,
+} from "./utils";
+
+// Per-run engine config (B3/PR8): build the engine context for THIS session. No
+// process-global env, no activeEngineSessionId mutex — each run threads its own context
+// via AsyncLocalStorage (engineContext.run), so concurrent engine-backed sessions are
+// fully isolated: no cross-tenant API-key bleed and no serialization.
+function engineContextFor(session: SessionRecord): EngineContext | null {
+	if (!session.engine.enabled || !session.engine.url) {
+		return null;
+	}
+	return {
+		url: session.engine.url,
+		repositoryId: session.engine.repositoryId || "",
+		snapshotId: session.engine.snapshotId || "",
+		apiKey: session.engine.apiKey || "",
+		workingDir: session.workingDir,
+	};
+}
+
+export interface ExecutionContext {
+	proofContext: ProofRuntimeContext;
+	runtimeIdentity: RuntimeIdentity;
+	state: ServerState;
+}
+
+export function buildRunAgentArgs(session: SessionRecord): RunAgentArgs {
+	const engine = engineContextFor(session);
+	return {
+		working_dir: session.workingDir,
+		prompt: session.prompt,
+		injected_context: session.injectedContext,
+		task_kind: session.taskKind ?? "fix",
+		provider: session.provider,
+		model: session.model,
+		provider_api_key: session.providerApiKey,
+		require_provider_api_key: session.requireProviderApiKey,
+		base_url: session.baseUrl,
+		headers: session.headers,
+		suppress_exploration: session.suppressExploration,
+		tool_profile: session.toolProfile,
+		limits: session.limits,
+		enable_spawn_agent: session.enableSpawnAgent,
+		enable_agent_teams: session.enableAgentTeams,
+		// gates the Algenta tools/govern-hook in buildStartConfig (engineEnabled)
+		engine: engine ? { enabled: true, ...engine } : undefined,
+	};
+}
+
+export async function startSession(
+	context: ExecutionContext,
+	session: SessionRecord,
+	promptOverride?: string,
+): Promise<SessionRecord> {
+	if (session.cline) {
+		return session;
+	}
+	const runArgs = buildRunAgentArgs(session);
+	const provider = await resolveProviderConfig(runArgs);
+	const cline = await ClineCore.create({
+		clientName: "algenta-agent-core",
+		backendMode: "local",
+		toolPolicies: session.policy.toolPolicies,
+	});
+	const startInput = buildStartConfig(runArgs, provider);
+	startInput.config.sessionId = session.sessionId;
+	startInput.config.systemPrompt = `${
+		startInput.config.systemPrompt
+	}\n\n[ALGENTA EXECUTION POLICY]\napproval_profile=${session.approvalProfile}\nchannel=${session.channel}\nrepository_scope=${session.repositoryScope}\nallowed_write_scope=${session.policy.allowedWriteScope.join(",") || "none"}`;
+	const unsubscribe = cline.subscribe((event) => {
+		if (
+			event.type === "ended" &&
+			event.payload.sessionId !== session.sessionId
+		) {
+			return;
+		}
+		if (
+			"payload" in event &&
+			event.type !== "team_progress" &&
+			optionalString(
+				(event as { payload?: { sessionId?: string } }).payload?.sessionId,
+			) &&
+			(event as { payload: { sessionId?: string } }).payload.sessionId !==
+				session.sessionId
+		) {
+			return;
+		}
+		onCoreSessionEvent(session, event);
+	});
+	session.cline = cline;
+	session.unsubscribe = unsubscribe;
+	appendSessionEvent(session, "session.start_requested", {
+		provider: provider.providerId,
+		model: provider.modelId,
+	});
+	const started = await cline.start(startInput);
+	session.startedSession = {
+		sessionId: started.sessionId,
+		manifestPath: started.manifestPath,
+		messagesPath: started.messagesPath,
+	};
+	session.provider = provider.providerId;
+	session.model = provider.modelId;
+	session.state = "started";
+	updateSessionTimestamp(session);
+	appendSessionEvent(session, "session.started", {
+		session_id: started.sessionId,
+		manifest_path: started.manifestPath,
+		messages_path: started.messagesPath,
+	});
+	if (promptOverride) {
+		await runSessionTurn(context, session, promptOverride);
+	}
+	return session;
+}
+
+/**
+ * Enforce the per-turn timeout budget at the server layer (Wave A1). The SDK
+ * runtime host does not currently honor `timeoutMs` (the 14-minute hang); race the
+ * send against the budget and best-effort abort the run so a stuck/looping turn
+ * surfaces a clean timeout instead of holding the single process. B-wave moves this
+ * onto a provider-level AbortController.
+ */
+async function sendTurnWithTimeout(
+	session: SessionRecord,
+	prompt: string,
+	timeoutMs: number,
+): Promise<Record<string, unknown> | undefined> {
+	const send = (
+		session.cline as unknown as {
+			send: (input: {
+				sessionId: string;
+				prompt: string;
+				mode: "act";
+				timeoutMs?: number;
+			}) => Promise<Record<string, unknown> | undefined>;
+		}
+	).send({ sessionId: session.sessionId, prompt, mode: "act", timeoutMs });
+
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	const timeout = new Promise<never>((_, reject) => {
+		timer = setTimeout(() => {
+			// best-effort: stop the underlying run so it isn't left burning tokens
+			Promise.resolve(session.cline?.abort(session.sessionId)).catch(() => undefined);
+			reject(new Error(`turn exceeded timeout budget of ${timeoutMs}ms`));
+		}, timeoutMs);
+	});
+	try {
+		return await Promise.race([send, timeout]);
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+}
+
+export async function runSessionTurn(
+	context: ExecutionContext,
+	session: SessionRecord,
+	prompt: string,
+): Promise<SessionRecord> {
+	if (!session.cline) {
+		throw new Error("session has not been started");
+	}
+	session.state = "running";
+	updateSessionTimestamp(session);
+	appendSessionEvent(session, "session.turn_requested", { prompt });
+	// Run the turn (and the tool calls it triggers) inside this session's engine context
+	// so the Algenta tools read THIS run's engine URL/key — never a shared global.
+	const engine = engineContextFor(session);
+	// Per-turn budget. A turn can legitimately run a model call + a full test step, so the default
+	// is generous (Cursor/Claude-Code-class, 10 min) and env-tunable — NOT a 2.5-min wall clock.
+	// The engine overrides this per-run via limits.timeoutMs; this is the floor for any other caller.
+	const defaultTurnMs = Number(process.env.AGENT_CORE_TURN_TIMEOUT_MS || 600_000);
+	const runTurn = () => sendTurnWithTimeout(session, prompt, session.limits?.timeoutMs ?? defaultTurnMs);
+	const result = engine ? await engineContext.run(engine, runTurn) : await runTurn();
+	session.lastResult = result ?? {};
+	try {
+		const usage = await session.cline.getAccumulatedUsage(session.sessionId);
+		session.lastUsage = usage?.aggregateUsage ?? usage?.usage ?? {};
+	} catch {
+		session.lastUsage = {};
+	}
+	try {
+		session.lastMessages = await session.cline.readMessages(session.sessionId);
+	} catch {
+		session.lastMessages = [];
+	}
+	const evidence = deriveToolCallEvidence(session);
+	session.approvalEvents = approvalEventsForTurn(
+		session,
+		evidence.toolCallsByName,
+	);
+	const finishReason = optionalString(result?.finishReason);
+	session.state =
+		finishReason === "aborted"
+			? "aborted"
+			: finishReason === "error"
+				? "failed"
+				: "completed";
+	await finalizeSessionArtifacts(
+		session,
+		context.proofContext,
+		context.runtimeIdentity,
+	);
+	return session;
+}
+
+export async function abortSession(
+	context: ExecutionContext,
+	session: SessionRecord,
+): Promise<void> {
+	if (session.cline) {
+		await session.cline.abort(session.sessionId);
+	}
+	session.state = "aborted";
+	updateSessionTimestamp(session);
+	appendSessionEvent(session, "session.aborted", {});
+	await finalizeSessionArtifacts(
+		session,
+		context.proofContext,
+		context.runtimeIdentity,
+	);
+}
+
+export async function stopSession(
+	context: ExecutionContext,
+	session: SessionRecord,
+): Promise<void> {
+	if (session.cline) {
+		await session.cline.stop(session.sessionId);
+	}
+	session.state = "stopped";
+	updateSessionTimestamp(session);
+	appendSessionEvent(session, "session.stopped", {});
+	await finalizeSessionArtifacts(
+		session,
+		context.proofContext,
+		context.runtimeIdentity,
+	);
+}
+
+export async function deleteSession(
+	context: ExecutionContext,
+	session: SessionRecord,
+): Promise<void> {
+	if (session.cline) {
+		try {
+			await session.cline.delete(session.sessionId);
+		} catch {
+			// Ignore delete failures; the in-memory contract remains authoritative here.
+		}
+	}
+	try {
+		session.unsubscribe?.();
+	} catch {
+		// Ignore cleanup failures.
+	}
+	context.state.sessions.delete(session.sessionId);
+	if (session.idempotencyKey) {
+		context.state.idempotencyIndex.delete(
+			[session.channel, session.repositoryScope, session.idempotencyKey].join(
+				":",
+			),
+		);
+	}
+}

codna/agent-core/vendor/cline/algenta/server/http.ts

@@ -0,0 +1,146 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { ServerState } from "./state";
+import type { SessionRecord } from "./contracts";
+import { matchesOwner } from "./utils";
+
+export function jsonResponse(
+	response: ServerResponse,
+	statusCode: number,
+	payload: unknown,
+): void {
+	response.writeHead(statusCode, { "content-type": "application/json" });
+	response.end(JSON.stringify(payload));
+}
+
+export function jsonError(
+	response: ServerResponse,
+	statusCode: number,
+	code: string,
+	message: string,
+	details: Record<string, unknown> = {},
+): void {
+	jsonResponse(response, statusCode, {
+		error: {
+			code,
+			message,
+			details,
+		},
+	});
+}
+
+export function ndjsonResponse(
+	response: ServerResponse,
+	frames: unknown[],
+): void {
+	response.writeHead(200, { "content-type": "application/x-ndjson" });
+	for (const frame of frames) {
+		response.write(`${JSON.stringify(frame)}\n`);
+	}
+	response.end();
+}
+
+export function sseResponse(response: ServerResponse, frames: unknown[]): void {
+	response.writeHead(200, {
+		"content-type": "text/event-stream",
+		"cache-control": "no-cache",
+		connection: "keep-alive",
+	});
+	for (const frame of frames) {
+		response.write(`event: session_event\ndata: ${JSON.stringify(frame)}\n\n`);
+	}
+	response.end();
+}
+
+// Wave A1: cap request bodies so an oversized/streaming payload can't exhaust
+// memory on the single process. Tunable via AGENT_CORE_MAX_BODY_BYTES.
+const MAX_BODY_BYTES = Number(process.env.AGENT_CORE_MAX_BODY_BYTES || 8 * 1024 * 1024);
+
+export async function readJsonBody(
+	request: IncomingMessage,
+): Promise<Record<string, unknown>> {
+	const chunks: Buffer[] = [];
+	let total = 0;
+	for await (const chunk of request) {
+		const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		total += buf.length;
+		if (total > MAX_BODY_BYTES) {
+			request.destroy();
+			throw new Error(`request body too large (>${MAX_BODY_BYTES} bytes)`);
+		}
+		chunks.push(buf);
+	}
+	if (chunks.length === 0) return {};
+	try {
+		return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+	} catch {
+		throw new Error("invalid json body");
+	}
+}
+
+export function routeMatch(request: IncomingMessage, host: string): {
+	path: string;
+	parts: string[];
+} {
+	const url = new URL(request.url || "/", `http://${host}`);
+	const pathName = url.pathname.replace(/\/+$/, "") || "/";
+	return {
+		path: pathName,
+		parts: pathName.split("/").filter(Boolean),
+	};
+}
+
+// B7 (PR10b): the agent-core sidecar is an internal service; gate it so only the trusted
+// caller (the API server / worker, which holds the shared bearer) can reach the
+// session/run surface. With a token configured (or AGENT_CORE_REQUIRE_AUTH=1) an
+// unauthenticated request is rejected; with neither set the server stays open for local
+// loopback dev (backward compatible). /health and /ready stay open for probes.
+export function isAuthorizedRequest(request: IncomingMessage): boolean {
+	const token = process.env.AGENT_CORE_AUTH_TOKEN;
+	const required = process.env.AGENT_CORE_REQUIRE_AUTH === "1" || Boolean(token);
+	if (!required) return true;
+	if (!token) return false; // auth required but no token configured => fail closed
+	const header = request.headers.authorization;
+	const value = Array.isArray(header) ? header[0] : header;
+	return typeof value === "string" && value === `Bearer ${token}`;
+}
+
+export function isLocalRuntimeControlRequest(request: IncomingMessage): boolean {
+	if (process.env.CODNA_LOCAL_RUNTIME !== "1") return false;
+	const expectedRuntimeId = process.env.CODNA_RUNTIME_ID;
+	if (!expectedRuntimeId) return false;
+	const header = request.headers["x-codna-runtime-id"];
+	const runtimeId = Array.isArray(header) ? header[0] : header;
+	if (runtimeId !== expectedRuntimeId) return false;
+	const remoteAddress = request.socket.remoteAddress;
+	return (
+		remoteAddress === "127.0.0.1" ||
+		remoteAddress === "::1" ||
+		remoteAddress === "::ffff:127.0.0.1"
+	);
+}
+
+export function requireSession(
+	request: IncomingMessage,
+	response: ServerResponse,
+	state: ServerState,
+	sessionId: string,
+): SessionRecord | undefined {
+	const session = state.sessions.get(sessionId);
+	if (!session) {
+		jsonError(response, 404, "session_not_found", `Unknown session: ${sessionId}`, {
+			session_id: sessionId,
+		});
+		return undefined;
+	}
+	if (!matchesOwner(request, session)) {
+		jsonError(
+			response,
+			403,
+			"session_owner_mismatch",
+			`Session ${sessionId} is owned by ${session.owner}.`,
+			{ session_id: sessionId, owner: session.owner },
+		);
+		return undefined;
+	}
+	return session;
+}