@gajae-code/coding-agent 0.12.8 → 0.12.10

package/src/discovery/agents-md.ts

@@ -5,56 +5,113 @@
  * This handles AGENTS.md files that live in project root (not in config directories
  * like .OpenAI code backend/ or .gemini/, which are handled by their respective providers).
  */
+import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { registerProvider } from "../capability";
 import { type ContextFile, contextFileCapability } from "../capability/context-file";
-import { readFile } from "../capability/fs";
 import type { LoadContext, LoadResult } from "../capability/types";
 import { calculateDepth, createSourceMeta } from "./helpers";
 
 const PROVIDER_ID = "agents-md";
 const DISPLAY_NAME = "AGENTS.md";
+// Bound hostile ancestor walks and instruction payloads before they reach prompt assembly.
+const MAX_ANCESTOR_DIRECTORIES = 32;
+const MAX_FILE_BYTES = 64 * 1024;
+const MAX_AGGREGATE_BYTES = 256 * 1024;
+const DIRECTORY_LIMIT_WARNING = "AGENTS.md discovery stopped after scanning 32 ancestor directories.";
+const FILE_LIMIT_WARNING = "Skipped one or more AGENTS.md files that exceed the 64 KiB limit.";
+const AGGREGATE_LIMIT_WARNING = "Skipped one or more AGENTS.md files that exceed the 256 KiB aggregate limit.";
+
+export type AgentsMdReader = (
+	filePath: string,
+	maxBytes: number,
+) => Promise<{ content: string | null; byteLength: number; tooLarge: boolean }>;
+
+async function readBoundedAgentsMdFile(
+	filePath: string,
+	maxBytes: number,
+): Promise<{ content: string | null; byteLength: number; tooLarge: boolean }> {
+	try {
+		const file = await fs.open(filePath, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK);
+		try {
+			const stats = await file.stat();
+			if (!stats.isFile()) return { content: null, byteLength: 0, tooLarge: false };
+			const bytes = Buffer.alloc(maxBytes + 1);
+			let bytesRead = 0;
+			while (bytesRead < bytes.length) {
+				const result = await file.read(bytes, bytesRead, bytes.length - bytesRead, bytesRead);
+				if (result.bytesRead === 0) break;
+				bytesRead += result.bytesRead;
+			}
+			if (bytesRead > maxBytes) return { content: null, byteLength: bytesRead, tooLarge: true };
+			return {
+				content: new TextDecoder().decode(bytes.subarray(0, bytesRead)),
+				byteLength: bytesRead,
+				tooLarge: false,
+			};
+		} finally {
+			await file.close();
+		}
+	} catch {
+		return { content: null, byteLength: 0, tooLarge: false };
+	}
+}
 
 /**
  * Load standalone AGENTS.md files.
  */
-async function loadAgentsMd(ctx: LoadContext): Promise<LoadResult<ContextFile>> {
+export async function loadAgentsMd(
+	ctx: LoadContext,
+	readCandidate: AgentsMdReader = readBoundedAgentsMdFile,
+): Promise<LoadResult<ContextFile>> {
 	const items: ContextFile[] = [];
 	const warnings: string[] = [];
-
-	// Walk up from cwd looking for AGENTS.md files
 	let current = ctx.cwd;
+	let scannedDirectories = 0;
+	let aggregateBytes = 0;
+	let omittedOversizedFile = false;
+	let omittedAggregateFile = false;
 
 	while (true) {
+		scannedDirectories += 1;
 		const candidate = path.join(current, "AGENTS.md");
-		const content = await readFile(candidate);
-
-		if (content !== null) {
-			const parent = path.dirname(candidate);
-			const baseName = parent.split(path.sep).pop() ?? "";
+		const parent = path.dirname(candidate);
+		const baseName = parent.split(path.sep).pop() ?? "";
 
-			if (!baseName.startsWith(".")) {
+		if (!baseName.startsWith(".")) {
+			const remainingAggregateBytes = MAX_AGGREGATE_BYTES - aggregateBytes;
+			const allowedBytes = Math.min(MAX_FILE_BYTES, remainingAggregateBytes);
+			const result = await readCandidate(candidate, allowedBytes);
+			if (result.tooLarge) {
+				if (allowedBytes < MAX_FILE_BYTES) omittedAggregateFile = true;
+				else omittedOversizedFile = true;
+			} else if (result.content !== null) {
 				const fileDir = path.dirname(candidate);
-				const calculatedDepth = calculateDepth(ctx.cwd, fileDir, path.sep);
-
 				items.push({
 					path: candidate,
-					content,
+					content: result.content,
 					level: "project",
-					depth: calculatedDepth,
+					depth: calculateDepth(ctx.cwd, fileDir, path.sep),
 					_source: createSourceMeta(PROVIDER_ID, candidate, "project"),
 				});
+				aggregateBytes += result.byteLength;
 			}
 		}
 
-		if (current === (ctx.repoRoot ?? ctx.home)) break; // scanned repo root or home, stop
+		const stopDirectory = ctx.repoRoot ?? ctx.home;
+		if (current === stopDirectory) break;
+		if (scannedDirectories === MAX_ANCESTOR_DIRECTORIES) {
+			warnings.push(DIRECTORY_LIMIT_WARNING);
+			break;
+		}
 
-		// Move to parent directory
-		const parent = path.dirname(current);
-		if (parent === current) break; // Reached filesystem root
-		current = parent;
+		const parentDirectory = path.dirname(current);
+		if (parentDirectory === current) break;
+		current = parentDirectory;
 	}
 
+	if (omittedOversizedFile) warnings.push(FILE_LIMIT_WARNING);
+	if (omittedAggregateFile) warnings.push(AGGREGATE_LIMIT_WARNING);
 	return { items, warnings };
 }
 

package/src/gjc-runtime/psmux-detect.ts

@@ -324,25 +324,21 @@ export function resolveGjcTmuxBinary(options: ResolveGjcTmuxBinaryOptions = {}):
 		return { command: explicit, isPsmux, viaExplicitOverride: true };
 	}
 	if (platform === "win32") {
-		const candidates: Array<{ command: string; identity: string }> = [];
-		for (const candidate of PSMUX_BINARY_NAMES) {
-			const executablePath = resolveBinaryPath(candidate);
+		for (const command of ["psmux", "pmux"] as const) {
+			const executablePath = resolveBinaryPath(command);
 			if (!executablePath) continue;
-			const isPsmuxAlias = candidate !== "tmux" || detectPsmuxForCommand(candidate, runner);
-			if (!isPsmuxAlias) continue;
-			const identity = activeExecutableIdentityResolver(executablePath);
-			if (!identity)
-				throw new Error(`gjc_tmux_provider_ambiguous: Windows ${candidate} executable identity is unavailable`);
-			candidates.push({ command: candidate, identity });
+			if (!activeExecutableIdentityResolver(executablePath))
+				throw new Error(`gjc_tmux_provider_ambiguous: Windows ${command} executable identity is unavailable`);
+			return { command, isPsmux: true, viaExplicitOverride: false };
 		}
-		if (candidates.length > 0) {
-			const identities = new Set(candidates.map(candidate => candidate.identity));
-			if (identities.size !== 1)
-				throw new Error("gjc_tmux_provider_ambiguous: Windows psmux aliases resolve to different executables");
-			// The order is the canonical provider spelling, then its compatibility
-			// aliases. Identity equality above makes PATH-order alias selection safe.
-			return { command: candidates[0]!.command, isPsmux: true, viaExplicitOverride: false };
+		const tmuxPath = resolveBinaryPath("tmux");
+		if (tmuxPath) {
+			const isPsmux = outputMentionsPsmux(probeVersionOutput(tmuxPath, runner));
+			if (isPsmux && !activeExecutableIdentityResolver(tmuxPath))
+				throw new Error("gjc_tmux_provider_ambiguous: Windows tmux executable identity is unavailable");
+			return { command: "tmux", isPsmux, viaExplicitOverride: false };
 		}
+		return { command: "tmux", isPsmux: false, viaExplicitOverride: false };
 	}
 	const tmuxPath = resolveBinaryPath("tmux");
 	if (tmuxPath) {

package/src/gjc-runtime/tmux-sessions.ts

@@ -228,7 +228,7 @@ function runTmux(
 			);
 	}
 	if (result.exitCode === 0) return result.stdout?.toString() ?? "";
-	throw new Error(result.stderr?.toString().trim() || `tmux ${args.join(" ")} failed`);
+	throw new Error(result.stderr?.toString().trim() || `${tmuxCommand} ${args.join(" ")} failed`);
 }
 function normalizeExactTmuxTarget(sessionTarget: string, env: NodeJS.ProcessEnv, kind: "session" | "option"): string {
 	if (sessionTarget.startsWith("$")) return sessionTarget;
@@ -407,6 +407,13 @@ function psmuxAuthorityEnvironments(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv[]
 			if (authorities.length > 0)
 				return authorities.map(authority => environmentForProviderAuthority(env, authority));
 		}
+		if (!ambient.viaExplicitOverride && !ambientAvailable) {
+			throw new Error(
+				"gjc_tmux_provider_unavailable — GJC searched for psmux, pmux, and tmux on PATH. " +
+					"Install psmux from https://github.com/psmux/psmux for native Windows support, use WSL with real tmux, " +
+					"or set GJC_TMUX_COMMAND (and GJC_PSMUX_COMMAND when selecting a psmux compatibility alias).",
+			);
+		}
 	}
 	if (ambient.isPsmux) throw new Error("gjc_tmux_provider_authority_unavailable");
 	return [env];