@gajae-code/coding-agent 0.17.2 → 0.17.5

package/src/runtime/network-prewarm-service.test.ts

@@ -42,7 +42,42 @@ describe("network prewarm runtime service", () => {
 		const runtime = await service.get("legacy-startup");
 		runtime.preconnect("https://example.test");
 
-		expect(calls).toEqual(["https://example.test"]);
+		expect(calls).toEqual(["https://example.test:443/"]);
+		await service.dispose();
+	});
+
+	test("normalizes a portless HTTPS model host before preconnect", async () => {
+		const calls: string[] = [];
+		const fetchWithPreconnect = Object.assign(async () => new Response("ok"), {
+			preconnect: (url: string) => {
+				calls.push(url);
+			},
+		}) as typeof fetch & { preconnect: (url: string) => void };
+		globalThis.fetch = fetchWithPreconnect;
+
+		const service = createNetworkPrewarmService(Settings.isolated());
+		const runtime = await service.get("portless-https");
+		runtime.preconnect("https://api.anthropic.com/v1/messages");
+
+		expect(calls).toEqual(["https://api.anthropic.com:443/v1/messages"]);
+		await service.dispose();
+	});
+
+	test("falls back to Bun's accepted TCP form when default-port HTTPS is rejected", async () => {
+		const calls: string[] = [];
+		const fetchWithPreconnect = Object.assign(async () => new Response("ok"), {
+			preconnect: (url: string) => {
+				calls.push(url);
+				if (url.startsWith("https://")) throw new TypeError("Invalid port");
+			},
+		}) as typeof fetch & { preconnect: (url: string) => void };
+		globalThis.fetch = fetchWithPreconnect;
+
+		const service = createNetworkPrewarmService(Settings.isolated());
+		const runtime = await service.get("bun-1.4.0");
+		runtime.preconnect("https://api.anthropic.com");
+
+		expect(calls).toEqual(["https://api.anthropic.com:443/", "http://api.anthropic.com:443/"]);
 		await service.dispose();
 	});
 });

package/src/runtime/network-prewarm-service.ts

@@ -4,6 +4,24 @@ import { createLazyService, type LazyService } from "./lazy-service";
 
 type FetchWithPreconnect = typeof fetch & { preconnect?: (url: string) => void };
 
+function withDefaultPort(baseUrl: string): { normalized: string; fallback?: string } {
+	try {
+		const parsed = new URL(baseUrl);
+		if (parsed.port || parsed.protocol !== "https:") return { normalized: baseUrl };
+		const port = "443";
+		const path = `${parsed.pathname}${parsed.search}${parsed.hash}`;
+		const authority = parsed.host;
+		const normalized = `${parsed.protocol}//${authority}:${port}${path}`;
+		// Bun 1.4.0 rejects the default port after WHATWG URL normalization. Its
+		// HTTP-form URL still reaches the same port and keeps the TCP warmup alive
+		// until the runtime accepts the canonical HTTPS form.
+		const fallback = parsed.protocol === "https:" ? `http://${authority}:${port}${path}` : undefined;
+		return { normalized, fallback };
+	} catch {
+		return { normalized: baseUrl };
+	}
+}
+
 /** Runtime network prewarm and first-request latency diagnostics. */
 export interface NetworkPrewarmRuntime {
 	enabled: boolean;
@@ -30,11 +48,18 @@ export function createNetworkPrewarmService(settings: Settings): LazyService<Net
 						if (!enabled || !baseUrl) return;
 						const preconnect = (globalThis.fetch as FetchWithPreconnect).preconnect;
 						if (typeof preconnect !== "function") return;
+						const { normalized, fallback } = withDefaultPort(baseUrl);
 						try {
-							preconnect(baseUrl);
+							preconnect(normalized);
 						} catch (error) {
-							// Preserve the legacy best-effort optimization contract while keeping
-							// the diagnostic visible to debug logging.
+							if (fallback) {
+								try {
+									preconnect(fallback);
+									return;
+								} catch {
+									// Fall through to the best-effort diagnostic below.
+								}
+							}
 							logger.debug("Model-host preconnect failed", {
 								baseUrl,
 								error: error instanceof Error ? error.message : String(error),

package/src/runtime/process-lifecycle.ts

@@ -436,6 +436,7 @@ type ResourceDisposer = () => void | Promise<void>;
 
 const resourceOwners = new Map<string, ResourceDisposer>();
 let resourcePostmortemRegistered = false;
+let activeResourceOwnerDisposals = 0;
 
 function ensureResourcePostmortem(): void {
 	if (resourcePostmortemRegistered) return;
@@ -477,23 +478,33 @@ export function resourceOwnerCount(): number {
 	return resourceOwners.size;
 }
 
+/** True while a process-level resource-owner sweep is in progress. */
+export function isResourceOwnerDisposalActive(): boolean {
+	return activeResourceOwnerDisposals > 0;
+}
+
 /**
  * Run and clear every registered resource disposer. Attempts all disposers even
  * if some throw, then surfaces the failures as an `AggregateError` so callers
  * can distinguish "all closed" from "a resource may still be alive".
  */
 export async function disposeAllResourceOwners(): Promise<void> {
-	const disposers = [...resourceOwners.values()];
-	resourceOwners.clear();
-	const errors: unknown[] = [];
-	for (const disposer of disposers) {
-		try {
-			await disposer();
-		} catch (err) {
-			errors.push(err);
+	activeResourceOwnerDisposals += 1;
+	try {
+		const disposers = [...resourceOwners.values()];
+		resourceOwners.clear();
+		const errors: unknown[] = [];
+		for (const disposer of disposers) {
+			try {
+				await disposer();
+			} catch (err) {
+				errors.push(err);
+			}
 		}
-	}
-	if (errors.length > 0) {
-		throw new AggregateError(errors, `${errors.length} resource disposer(s) failed during teardown`);
+		if (errors.length > 0) {
+			throw new AggregateError(errors, `${errors.length} resource disposer(s) failed during teardown`);
+		}
+	} finally {
+		activeResourceOwnerDisposals -= 1;
 	}
 }

package/src/runtime-mcp/config.ts

@@ -4,7 +4,7 @@
  * Uses the capability system to load MCP servers from multiple sources.
  */
 
-import { getMCPConfigPath } from "@gajae-code/utils";
+import { getMCPConfigPath, logger } from "@gajae-code/utils";
 import { mcpCapability } from "../capability/mcp";
 import type { SourceMeta } from "../capability/types";
 import type { Settings } from "../config/settings";
@@ -16,6 +16,14 @@ import { canonicalizeMCPEndpoint } from "./pool-key";
 import { isMCPProtocolPreference } from "./protocol";
 import type { MCPServerConfig } from "./types";
 
+function logSkippedServer(name: string, reason: string): void {
+	logger.warn("Skipping MCP autoload registration", {
+		path: `mcp:${name}`,
+		serverName: name,
+		reason,
+	});
+}
+
 /** Options for loading MCP configs */
 export interface LoadMCPConfigsOptions {
 	/** Owning session settings for capability filtering. */
@@ -174,9 +182,16 @@ export async function loadAllMCPConfigs(cwd: string, options?: LoadMCPConfigsOpt
 	for (const server of servers) {
 		const config = convertToLegacyConfig(server);
 		if (config.enabled === false || disabledServers.has(server.name)) {
+			if (!exactConfig) {
+				logSkippedServer(
+					server.name,
+					config.enabled === false ? "registration is disabled" : "server is listed in disabledServers",
+				);
+			}
 			continue;
 		}
 		if (autoloadOnly && config.autoload === false) {
+			if (!exactConfig) logSkippedServer(server.name, "autoload is disabled for this registration");
 			continue;
 		}
 		configs[server.name] = config;

package/src/runtime-mcp/loader.ts

@@ -44,10 +44,13 @@ export interface MCPToolsLoadOptions {
 	sharedPoolIdleMs?: number;
 }
 
-async function resolveToolCache(storage: AgentStorage | null | undefined): Promise<MCPToolCache | null> {
+export async function resolveMCPToolCache(
+	storage?: AgentStorage | null,
+	dbPath?: string,
+): Promise<MCPToolCache | null> {
 	if (storage === null) return null;
 	try {
-		const resolved = storage ?? (await AgentStorage.open());
+		const resolved = storage ?? (await AgentStorage.open(dbPath));
 		return new MCPToolCache(resolved);
 	} catch (error) {
 		logger.warn("MCP tool cache unavailable", { error: String(error) });
@@ -63,7 +66,7 @@ async function resolveToolCache(storage: AgentStorage | null | undefined): Promi
  * @returns MCP tools in LoadedCustomTool format for integration
  */
 export async function discoverAndLoadMCPTools(cwd: string, options?: MCPToolsLoadOptions): Promise<MCPToolsLoadResult> {
-	const toolCache = await resolveToolCache(options?.cacheStorage);
+	const toolCache = await resolveMCPToolCache(options?.cacheStorage);
 	const manager = new MCPManager(cwd, toolCache, { sharedPoolIdleMs: options?.sharedPoolIdleMs });
 	if (options?.authStorage) {
 		manager.setAuthStorage(options.authStorage);