@gajae-code/coding-agent 0.18.7 → 0.18.9

package/src/eval/py/kernel.ts

@@ -77,6 +77,26 @@ interface KernelStartOptions extends KernelLifecycleOptions {
 	env?: Record<string, string | undefined>;
 	runtimeOptions?: PythonRuntimeOptions;
 	settings?: Settings;
+	/** @internal Synchronously registers the actual spawned kernel before startup callbacks run. */
+	onKernelCreated?: (kernel: PythonKernel) => void;
+	/** @internal Routes partial-start cleanup through the executor's retained ownership. */
+	onStartupFailure?: (kernel: PythonKernel) => Promise<void>;
+}
+
+export type PythonKernelStartupCleanupFailure =
+	| { kind: "unconfirmed"; result: KernelShutdownResult }
+	| { kind: "rejected"; error: unknown };
+
+/** Startup failed after a real runner was created and physical cleanup failed. */
+export class PythonKernelStartError extends Error {
+	constructor(
+		readonly kernel: PythonKernel,
+		readonly startupError: unknown,
+		readonly cleanupFailure: PythonKernelStartupCleanupFailure,
+	) {
+		super("Python kernel startup failed and runner cleanup was not confirmed", { cause: startupError });
+		this.name = "PythonKernelStartError";
+	}
 }
 
 interface KernelShutdownOptions {
@@ -108,6 +128,13 @@ function throwIfAborted(signal: AbortSignal | undefined, fallbackReason: string)
 	throw createAbortError("AbortError", typeof reason === "string" ? reason : fallbackReason);
 }
 
+function throwIfLifecycleEnded(lifecycle: KernelLifecycleOptions, message: string): void {
+	throwIfAborted(lifecycle.signal, message);
+	if (lifecycle.deadlineMs !== undefined && lifecycle.deadlineMs <= Date.now()) {
+		throw createAbortError("TimeoutError", `${message} timed out`);
+	}
+}
+
 async function waitForLifecycle<T>(
 	value: Promise<T>,
 	lifecycle: PythonRuntimeLifecycleOptions | undefined,
@@ -244,6 +271,7 @@ export class PythonKernel {
 	#alive = true;
 	#disposed = false;
 	#shutdownConfirmed = false;
+	#shutdownPromise: Promise<KernelShutdownResult> | null = null;
 	#exitedPromise: Promise<number> | null = null;
 	#exitCode: number | null = null;
 	#stderrTail = "";
@@ -255,6 +283,7 @@ export class PythonKernel {
 	}
 
 	static async start(options: KernelStartOptions): Promise<PythonKernel> {
+		throwIfLifecycleEnded(options, "Python kernel startup");
 		const availability = await logger.time(
 			"PythonKernel.start:availabilityCheck",
 			checkPythonKernelAvailability,
@@ -263,17 +292,20 @@ export class PythonKernel {
 			{ signal: options.signal, deadlineMs: options.deadlineMs },
 			options.settings,
 		);
+		throwIfLifecycleEnded(options, "Python kernel startup");
 		if (!availability.ok) {
 			throw new Error(availability.reason ?? "Python kernel unavailable");
 		}
 
 		const settings = options.settings ?? (await Settings.init());
+		throwIfLifecycleEnded(options, "Python kernel startup");
 		const { env: shellEnv } = settings.getShellConfig();
 		const baseEnv = filterEnv(shellEnv);
 		const runtime = await ensurePythonRuntime(options.cwd, baseEnv, options.runtimeOptions, {
 			signal: options.signal,
 			deadlineMs: options.deadlineMs,
 		});
+		throwIfLifecycleEnded(options, "Python kernel startup");
 		const spawnEnv: Record<string, string> = {};
 		for (const [key, value] of Object.entries(runtime.env)) {
 			if (typeof value === "string") spawnEnv[key] = value;
@@ -286,6 +318,7 @@ export class PythonKernel {
 		spawnEnv.PYTHONIOENCODING = "utf-8";
 
 		const scriptPath = await ensureRunnerScript();
+		throwIfLifecycleEnded(options, "Python kernel startup");
 		const kernel = new PythonKernel(Snowflake.next());
 
 		const proc = Bun.spawn([runtime.pythonPath, "-u", scriptPath], {
@@ -302,25 +335,40 @@ export class PythonKernel {
 		kernel.#proc = proc;
 		kernel.#stdin = proc.stdin;
 		kernel.#exitedPromise = proc.exited;
-		void kernel.#exitedPromise.then(code => {
-			kernel.#exitCode = code;
-			kernel.#alive = false;
-			kernel.#abortPendingExecutions(`Python kernel exited with code ${code}`, { kernelKilled: true });
-		});
 
-		kernel.#startReader(proc.stdout as ReadableStream<Uint8Array>);
-		kernel.#startStderrDrain(proc.stderr as ReadableStream<Uint8Array>);
+		try {
+			options.onKernelCreated?.(kernel);
+			void kernel.#exitedPromise.then(code => {
+				kernel.#exitCode = code;
+				kernel.#alive = false;
+				kernel.#abortPendingExecutions(`Python kernel exited with code ${code}`, { kernelKilled: true });
+			});
 
-		const startup = { signal: options.signal, deadlineMs: options.deadlineMs };
-		const startupBudget = Math.min(getRemainingTimeMs(startup.deadlineMs) ?? STARTUP_TIMEOUT_MS, STARTUP_TIMEOUT_MS);
+			kernel.#startReader(proc.stdout as ReadableStream<Uint8Array>);
+			kernel.#startStderrDrain(proc.stderr as ReadableStream<Uint8Array>);
 
-		try {
+			const startup = { signal: options.signal, deadlineMs: options.deadlineMs };
+			const startupBudget = Math.min(
+				getRemainingTimeMs(startup.deadlineMs) ?? STARTUP_TIMEOUT_MS,
+				STARTUP_TIMEOUT_MS,
+			);
 			const initScript = buildInitScript(options.cwd, options.env);
 			await kernel.#executeWithBudget(initScript, startup.signal, startupBudget, "Python kernel init");
 			await kernel.#executeWithBudget(PYTHON_PRELUDE, startup.signal, startupBudget, "Python kernel prelude");
 			return kernel;
 		} catch (err) {
-			await kernel.shutdown({ timeoutMs: SHUTDOWN_GRACE_MS }).catch(() => {});
+			let cleanupFailure: PythonKernelStartupCleanupFailure | undefined;
+			try {
+				if (options.onStartupFailure) {
+					await options.onStartupFailure(kernel);
+				} else {
+					const result = await kernel.shutdown({ timeoutMs: SHUTDOWN_GRACE_MS });
+					if (!result.confirmed) cleanupFailure = { kind: "unconfirmed", result };
+				}
+			} catch (cleanupError) {
+				cleanupFailure = { kind: "rejected", error: cleanupError };
+			}
+			if (cleanupFailure) throw new PythonKernelStartError(kernel, err, cleanupFailure);
 			throw err;
 		}
 	}
@@ -475,9 +523,27 @@ export class PythonKernel {
 		}
 	}
 
-	async shutdown(options?: KernelShutdownOptions): Promise<KernelShutdownResult> {
-		if (this.#shutdownConfirmed) return { confirmed: true };
+	shutdown(options?: KernelShutdownOptions): Promise<KernelShutdownResult> {
+		if (this.#shutdownConfirmed) return Promise.resolve({ confirmed: true });
+		if (this.#shutdownPromise) return this.#shutdownPromise;
+
+		const { promise, resolve, reject } = Promise.withResolvers<KernelShutdownResult>();
+		this.#shutdownPromise = promise;
+		void promise.then(
+			() => {
+				if (this.#shutdownPromise === promise) this.#shutdownPromise = null;
+			},
+			() => {
+				if (this.#shutdownPromise === promise) this.#shutdownPromise = null;
+			},
+		);
+		void Promise.resolve()
+			.then(() => this.#shutdown(options))
+			.then(resolve, reject);
+		return promise;
+	}
 
+	async #shutdown(options?: KernelShutdownOptions): Promise<KernelShutdownResult> {
 		this.#alive = false;
 		this.#abortPendingExecutions("Python kernel shutdown", { kernelKilled: true });
 

package/src/eval/py/tool-bridge.ts

@@ -72,6 +72,10 @@ async function startServer(): Promise<BridgeServer> {
 			if (!sessionId || !name) {
 				return Response.json({ ok: false, error: "Missing session/name" }, { status: 400 });
 			}
+			const live = registrations.get(capability);
+			if (live !== registration || registration.signal?.aborted) {
+				return new Response("Forbidden", { status: 403 });
+			}
 			if (sessionId !== registration.sessionId) {
 				return new Response("Forbidden", { status: 403 });
 			}

package/src/export/html/css-color.ts

@@ -0,0 +1,9 @@
+const SAFE_CSS_COLOR =
+	/^(?:#[0-9a-fA-F]{3,8}|rgb\(\s*\d{1,3}\s*,\s*\d{1,3}\s*,\s*\d{1,3}\s*\)|rgba\(\s*\d{1,3}\s*,\s*\d{1,3}\s*,\s*\d{1,3}\s*,\s*(?:0|1|0?\.\d+)\s*\))$/;
+
+/** Keep a theme color that is safe to place in a `<style>` block. */
+export function cssColorOrFallback(value: string | undefined, fallback: string): string {
+	const trimmed = value?.trim();
+	if (trimmed && SAFE_CSS_COLOR.test(trimmed)) return trimmed;
+	return fallback;
+}

package/src/export/html/html-export-destination.ts

@@ -0,0 +1,16 @@
+import * as fs from "node:fs";
+
+const HTML_EXPORT_DESTINATION_OPEN_FLAGS =
+	fs.constants.O_WRONLY | fs.constants.O_CREAT | (process.platform === "win32" ? 0 : (fs.constants.O_NOFOLLOW ?? 0));
+
+/** Owner-only HTML export. A replaced file is locked down on the opened descriptor. */
+export function openHtmlExportDestination(outputPath: string): number {
+	const fd = fs.openSync(outputPath, HTML_EXPORT_DESTINATION_OPEN_FLAGS, 0o600);
+	try {
+		fs.fchmodSync(fd, 0o600);
+		return fd;
+	} catch (error) {
+		fs.closeSync(fd);
+		throw error;
+	}
+}

package/src/export/html/index.ts

@@ -6,6 +6,8 @@ import { APP_NAME, isEnoent } from "@gajae-code/utils";
 import { getResolvedThemeColors, getThemeExportColors } from "../../modes/theme/theme";
 import { SessionManager } from "../../session/session-manager";
 // Pre-generated template (created by scripts/generate-template.ts at publish time)
+import { cssColorOrFallback } from "./css-color";
+import { openHtmlExportDestination } from "./html-export-destination";
 import { TEMPLATE } from "./template.generated";
 
 export interface ExportOptions {
@@ -78,16 +80,16 @@ async function generateThemeVars(themeName?: string): Promise<string> {
 	const colors = await getResolvedThemeColors(themeName);
 	const lines: string[] = [];
 	for (const [key, value] of Object.entries(colors)) {
-		lines.push(`--${key}: ${value};`);
+		lines.push(`--${key}: ${cssColorOrFallback(value, "transparent")};`);
 	}
 
 	const themeExport = await getThemeExportColors(themeName);
 	const userMessageBg = colors.userMessageBg || "#343541";
 	const derived = deriveExportColors(userMessageBg);
 
-	lines.push(`--body-bg: ${themeExport.pageBg ?? derived.pageBg};`);
-	lines.push(`--container-bg: ${themeExport.cardBg ?? derived.cardBg};`);
-	lines.push(`--info-bg: ${themeExport.infoBg ?? derived.infoBg};`);
+	lines.push(`--body-bg: ${cssColorOrFallback(themeExport.pageBg, derived.pageBg)};`);
+	lines.push(`--container-bg: ${cssColorOrFallback(themeExport.cardBg, derived.cardBg)};`);
+	lines.push(`--info-bg: ${cssColorOrFallback(themeExport.infoBg, derived.infoBg)};`);
 
 	return lines.join(" ");
 }
@@ -168,11 +170,6 @@ const HTML_EXPORT_SOURCE_OPEN_FLAGS =
 	syncFs.constants.O_NONBLOCK |
 	(process.platform === "win32" ? 0 : (syncFs.constants.O_NOFOLLOW ?? 0));
 
-const HTML_EXPORT_DESTINATION_OPEN_FLAGS =
-	syncFs.constants.O_WRONLY |
-	syncFs.constants.O_CREAT |
-	(process.platform === "win32" ? 0 : (syncFs.constants.O_NOFOLLOW ?? 0));
-
 function sameFileIdentity(left: syncFs.BigIntStats, right: syncFs.BigIntStats): boolean {
 	return left.dev === right.dev && left.ino === right.ino;
 }
@@ -192,7 +189,7 @@ async function openHtmlExportDescriptors(
 			}
 			await assertExportDoesNotAliasSource(sourcePath, outputPath);
 		}
-		destination = syncFs.openSync(outputPath, HTML_EXPORT_DESTINATION_OPEN_FLAGS, 0o666);
+		destination = openHtmlExportDestination(outputPath);
 		if (source !== undefined) {
 			const sourceIdentity = syncFs.fstatSync(source, { bigint: true });
 			const destinationIdentity = syncFs.fstatSync(destination, { bigint: true });