@gajae-code/coding-agent 0.2.3 → 0.2.5

package/src/async/job-manager.ts

@@ -78,6 +78,56 @@ export interface AsyncJobFilter {
 	ownerId?: string;
 }
 
+function sliceTextFromUtf8ByteOffset(text: string, offsetBytes: number): string {
+	if (offsetBytes <= 0) return text;
+	let consumedBytes = 0;
+	let codeUnitIndex = 0;
+	for (const char of text) {
+		const charBytes = Buffer.byteLength(char, "utf8");
+		if (consumedBytes + charBytes > offsetBytes) break;
+		consumedBytes += charBytes;
+		codeUnitIndex += char.length;
+	}
+	return text.slice(codeUnitIndex);
+}
+
+/**
+ * A slice of process-stream output for a background job, as recorded by
+ * `appendOutput` / read by `readOutputSince`.
+ *
+ * The cursor model is monotonic UTF-8 byte offsets. `nextOffset` is the offset
+ * to pass to the next read to receive only fresh bytes; `startOffset` is the
+ * first byte the manager still retains for this job. When the requested offset
+ * is older than `startOffset`, the manager returns the retained tail and sets
+ * `truncated: true`.
+ */
+export interface AsyncJobOutputSlice {
+	jobId: string;
+	status: AsyncJob["status"];
+	text: string;
+	startOffset: number;
+	nextOffset: number;
+	truncated: boolean;
+}
+
+/** Internal: a single chunk of captured stdout/stderr keyed by its byte range. */
+interface AsyncJobOutputChunk {
+	startByte: number;
+	endByte: number;
+	text: string;
+}
+
+interface AsyncJobOutputState {
+	chunks: AsyncJobOutputChunk[];
+	startOffset: number;
+	nextOffset: number;
+	retainedBytes: number;
+}
+
+/** Default retention cap for per-job captured output. ~512 KiB matches the
+ *  bash tail-buffer order of magnitude without dominating session memory. */
+export const DEFAULT_JOB_OUTPUT_RETENTION_BYTES = 512 * 1024;
+
 export class AsyncJobManager {
 	static #instance: AsyncJobManager | undefined;
 
@@ -102,6 +152,9 @@ export class AsyncJobManager {
 	readonly #suppressedDeliveries = new Set<string>();
 	readonly #watchedJobs = new Set<string>();
 	readonly #evictionTimers = new Map<string, NodeJS.Timeout>();
+	readonly #outputState = new Map<string, AsyncJobOutputState>();
+	readonly #ownerCleanups = new Map<string, Set<() => void>>();
+	readonly #outputRetentionBytes = DEFAULT_JOB_OUTPUT_RETENTION_BYTES;
 	readonly #onJobComplete: AsyncJobManagerOptions["onJobComplete"];
 	readonly #maxRunningJobs: number;
 	readonly #retentionMs: number;
@@ -237,6 +290,169 @@ export class AsyncJobManager {
 		return this.#filterJobs(this.#jobs.values(), filter);
 	}
 
+	/**
+	 * Append a sanitized process-stream chunk for a background job. Called from
+	 * the unthrottled bash-executor capture hook (`onRawChunk`) so monitor sees
+	 * every chunk even when preview/progress callbacks are throttled.
+	 *
+	 * Offsets are in UTF-8 bytes. Storing chunk metadata avoids unsafe byte
+	 * slicing across multibyte characters at read time. The retention window is
+	 * a per-job rolling cap (`DEFAULT_JOB_OUTPUT_RETENTION_BYTES`); when it
+	 * overflows, oldest whole chunks are evicted and `startOffset` advances —
+	 * subsequent reads from a stale offset get `truncated: true`.
+	 */
+	appendOutput(jobId: string, chunk: string): void {
+		if (this.#disposed) return;
+		if (!chunk) return;
+		if (!this.#jobs.has(jobId)) return;
+
+		const state = this.#outputState.get(jobId) ?? {
+			chunks: [],
+			startOffset: 0,
+			nextOffset: 0,
+			retainedBytes: 0,
+		};
+
+		const byteLength = Buffer.byteLength(chunk, "utf8");
+		if (byteLength === 0) return;
+
+		const startByte = state.nextOffset;
+		const endByte = startByte + byteLength;
+		state.chunks.push({ startByte, endByte, text: chunk });
+		state.retainedBytes += byteLength;
+		state.nextOffset = endByte;
+
+		while (state.retainedBytes > this.#outputRetentionBytes && state.chunks.length > 0) {
+			const dropped = state.chunks.shift();
+			if (!dropped) break;
+			const droppedBytes = dropped.endByte - dropped.startByte;
+			state.retainedBytes -= droppedBytes;
+			state.startOffset = dropped.endByte;
+		}
+
+		this.#outputState.set(jobId, state);
+	}
+
+	/**
+	 * Read fresh process-stream output for a job since `offset` (in UTF-8
+	 * bytes). Returns `undefined` when the job does not exist or when an
+	 * `ownerId` filter is set and the job belongs to a different owner — this
+	 * mirrors the manager-level "not found" pattern used by `cancel`.
+	 *
+	 * - `offset < startOffset` returns the retained tail with `truncated: true`.
+	 * - `offset > nextOffset` clamps to `nextOffset` and returns an empty text
+	 *   slice with `truncated: false`.
+	 * - Assembled text slices the leading retained chunk at a UTF-8 codepoint
+	 *   boundary when needed, so multibyte characters cannot be split.
+	 */
+	readOutputSince(jobId: string, offset: number, filter?: AsyncJobFilter): AsyncJobOutputSlice | undefined {
+		const job = this.#jobs.get(jobId);
+		if (!job) return undefined;
+		if (filter?.ownerId && job.ownerId !== filter.ownerId) return undefined;
+
+		const state = this.#outputState.get(jobId);
+		if (!state) {
+			return {
+				jobId,
+				status: job.status,
+				text: "",
+				startOffset: 0,
+				nextOffset: 0,
+				truncated: false,
+			};
+		}
+
+		const requestedOffset = Math.max(0, Math.floor(offset));
+		if (requestedOffset >= state.nextOffset) {
+			return {
+				jobId,
+				status: job.status,
+				text: "",
+				startOffset: state.startOffset,
+				nextOffset: state.nextOffset,
+				truncated: false,
+			};
+		}
+
+		const truncated = requestedOffset < state.startOffset;
+		const effectiveOffset = truncated ? state.startOffset : requestedOffset;
+		const parts: string[] = [];
+		for (const chunk of state.chunks) {
+			if (chunk.endByte <= effectiveOffset) continue;
+			if (effectiveOffset > chunk.startByte) {
+				parts.push(sliceTextFromUtf8ByteOffset(chunk.text, effectiveOffset - chunk.startByte));
+				continue;
+			}
+			parts.push(chunk.text);
+		}
+
+		return {
+			jobId,
+			status: job.status,
+			text: parts.join(""),
+			startOffset: state.startOffset,
+			nextOffset: state.nextOffset,
+			truncated,
+		};
+	}
+
+	/**
+	 * Register an owner-scoped cleanup callback. Returns an unregister function.
+	 *
+	 * Used by Cron* tools to clear session-scoped timers when the owning agent
+	 * is torn down. Invoked by `runOwnerCleanups({ ownerId })` before
+	 * `cancelAll({ ownerId })` so timers cannot register new jobs during
+	 * teardown.
+	 */
+	registerOwnerCleanup(ownerId: string, cleanup: () => void): () => void {
+		if (!ownerId) {
+			throw new Error("registerOwnerCleanup requires a non-empty ownerId");
+		}
+		let bag = this.#ownerCleanups.get(ownerId);
+		if (!bag) {
+			bag = new Set();
+			this.#ownerCleanups.set(ownerId, bag);
+		}
+		bag.add(cleanup);
+		return () => {
+			const current = this.#ownerCleanups.get(ownerId);
+			if (!current) return;
+			current.delete(cleanup);
+			if (current.size === 0) this.#ownerCleanups.delete(ownerId);
+		};
+	}
+
+	/**
+	 * Run and clear every registered cleanup for the given filter. Idempotent
+	 * and error-isolated: a throwing cleanup does not prevent siblings from
+	 * running and never escalates to the caller.
+	 */
+	runOwnerCleanups(filter?: AsyncJobFilter): void {
+		const ownerId = filter?.ownerId;
+		const targets: Array<[string, Set<() => void>]> = [];
+		if (ownerId) {
+			const bag = this.#ownerCleanups.get(ownerId);
+			if (bag) targets.push([ownerId, bag]);
+		} else {
+			for (const entry of this.#ownerCleanups.entries()) targets.push(entry);
+		}
+		for (const [id, bag] of targets) {
+			const callbacks = Array.from(bag);
+			bag.clear();
+			this.#ownerCleanups.delete(id);
+			for (const cleanup of callbacks) {
+				try {
+					cleanup();
+				} catch (error) {
+					logger.warn("Async job owner cleanup failed", {
+						ownerId: id,
+						error: error instanceof Error ? error.message : String(error),
+					});
+				}
+			}
+		}
+	}
+
 	getDeliveryState(filter?: AsyncJobFilter): AsyncJobDeliveryState {
 		const deliveries = this.#filterDeliveries(filter);
 		const inFlightDeliveries = this.#filterInFlightDeliveries(filter);
@@ -357,6 +573,10 @@ export class AsyncJobManager {
 	async dispose(options?: { timeoutMs?: number }): Promise<boolean> {
 		this.#disposed = true;
 		this.#clearEvictionTimers();
+		// Run-and-clear any remaining owner cleanups before tearing down jobs so
+		// late-arriving timers cannot register fresh work against a disposed
+		// manager. Errors in cleanup callbacks are logged but never escalated.
+		this.runOwnerCleanups();
 		this.cancelAll();
 		await this.waitForAll();
 		const drained = await this.drainDeliveries({ timeoutMs: options?.timeoutMs ?? 3_000 });
@@ -366,6 +586,8 @@ export class AsyncJobManager {
 		this.#inFlightDeliveries.length = 0;
 		this.#suppressedDeliveries.clear();
 		this.#watchedJobs.clear();
+		this.#outputState.clear();
+		this.#ownerCleanups.clear();
 		return drained;
 	}
 
@@ -399,6 +621,7 @@ export class AsyncJobManager {
 			this.#jobs.delete(jobId);
 			this.#suppressedDeliveries.delete(jobId);
 			this.#watchedJobs.delete(jobId);
+			this.#outputState.delete(jobId);
 			return;
 		}
 		const existing = this.#evictionTimers.get(jobId);
@@ -410,6 +633,7 @@ export class AsyncJobManager {
 			this.#jobs.delete(jobId);
 			this.#suppressedDeliveries.delete(jobId);
 			this.#watchedJobs.delete(jobId);
+			this.#outputState.delete(jobId);
 		}, this.#retentionMs);
 		timer.unref();
 		this.#evictionTimers.set(jobId, timer);

package/src/cli/agents-cli.ts

@@ -64,6 +64,9 @@ function toFrontmatter(agent: AgentDefinition): Record<string, unknown> {
 	if (agent.thinkingLevel) frontmatter.thinkingLevel = agent.thinkingLevel;
 	if (agent.output !== undefined) frontmatter.output = agent.output;
 	if (agent.blocking) frontmatter.blocking = true;
+	if (agent.bashAllowedPrefixes && agent.bashAllowedPrefixes.length > 0) {
+		frontmatter.bashAllowedPrefixes = agent.bashAllowedPrefixes;
+	}
 
 	return frontmatter;
 }

package/src/cli/update-cli.ts

@@ -12,7 +12,7 @@ import { $ } from "bun";
 import chalk from "chalk";
 import { theme } from "../modes/theme/theme";
 
-const REPO = "can1357/gajae-code";
+const RELEASE_REPO = "Yeachan-Heo/gajae-code";
 const PACKAGE = "@gajae-code/coding-agent";
 
 interface ReleaseInfo {
@@ -122,7 +122,7 @@ async function resolveUpdateTarget(): Promise<UpdateTarget> {
 
 	if (bunBinDir) return { method: "bun" };
 
-	throw new Error(`Could not resolve ${APP_NAME} binary path in PATH`);
+	throw new Error(formatUnsupportedTargetMessage(`Could not resolve ${APP_NAME} binary path in PATH`));
 }
 
 /**
@@ -166,10 +166,7 @@ function compareVersions(a: string, b: string): number {
 /**
  * Get the appropriate binary name for this platform.
  */
-function getBinaryName(): string {
-	const platform = process.platform;
-	const arch = process.arch;
-
+function getBinaryName(platform: NodeJS.Platform = process.platform, arch: string = process.arch): string {
 	let os: string;
 	switch (platform) {
 		case "linux":
@@ -182,7 +179,7 @@ function getBinaryName(): string {
 			os = "windows";
 			break;
 		default:
-			throw new Error(`Unsupported platform: ${platform}`);
+			throw new Error(formatUnsupportedTargetMessage(`Unsupported platform: ${platform}`));
 	}
 
 	let archName: string;
@@ -194,7 +191,7 @@ function getBinaryName(): string {
 			archName = "arm64";
 			break;
 		default:
-			throw new Error(`Unsupported architecture: ${arch}`);
+			throw new Error(formatUnsupportedTargetMessage(`Unsupported architecture: ${arch}`));
 	}
 
 	if (os === "windows") {
@@ -233,6 +230,65 @@ function printVerifiedVersion(expectedVersion: string): void {
 	console.log(chalk.green(`\n${theme.status.success} Updated to ${expectedVersion}`));
 }
 
+function formatBinaryInstallInstruction(platform: NodeJS.Platform = process.platform): string {
+	if (platform === "win32") {
+		return `For a supported binary install, reinstall with PowerShell: irm https://raw.githubusercontent.com/${RELEASE_REPO}/main/scripts/install.ps1 | iex`;
+	}
+	return `For a supported binary install, reinstall with: curl -fsSL https://raw.githubusercontent.com/${RELEASE_REPO}/main/scripts/install.sh | sh -s -- --binary`;
+}
+
+function formatManualUpdateInstructions(platform: NodeJS.Platform = process.platform): string {
+	return [
+		`If ${APP_NAME} was installed with Bun, run: bun install -g ${PACKAGE}@latest`,
+		`If ${APP_NAME} was installed with npm, pnpm, or another package manager, update it with that same manager.`,
+		formatBinaryInstallInstruction(platform),
+	].join("\n");
+}
+
+function formatUnsupportedTargetMessage(reason: string, platform: NodeJS.Platform = process.platform): string {
+	return `${reason}.\n${formatManualUpdateInstructions(platform)}`;
+}
+
+function buildReleaseBinaryUrl(
+	version: string,
+	platform: NodeJS.Platform = process.platform,
+	arch: string = process.arch,
+): string {
+	const binaryName = getBinaryName(platform, arch);
+	const tag = `v${version}`;
+	return `https://github.com/${RELEASE_REPO}/releases/download/${tag}/${binaryName}`;
+}
+
+function formatBinaryDownloadFailureMessage(
+	binaryName: string,
+	url: string,
+	status: string | number,
+	platform: NodeJS.Platform = process.platform,
+): string {
+	return `Download failed for ${binaryName} from ${url}: ${status}.\n${formatManualUpdateInstructions(platform)}`;
+}
+
+export function formatBinaryDownloadFailureMessageForTest(
+	binaryName: string,
+	url: string,
+	status: string | number,
+	platform: NodeJS.Platform = process.platform,
+): string {
+	return formatBinaryDownloadFailureMessage(binaryName, url, status, platform);
+}
+
+export function buildReleaseBinaryUrlForTest(
+	version: string,
+	platform: NodeJS.Platform = process.platform,
+	arch: string = process.arch,
+): string {
+	return buildReleaseBinaryUrl(version, platform, arch);
+}
+
+export function formatManualUpdateInstructionsForTest(platform: NodeJS.Platform = process.platform): string {
+	return formatManualUpdateInstructions(platform);
+}
+
 function formatVerificationFailure(result: InstalledVersionVerification, expectedVersion: string): string {
 	if (result.actual) {
 		return `${APP_NAME} at ${result.path} still reports ${result.actual} (expected ${expectedVersion})`;
@@ -250,11 +306,7 @@ async function printVerification(expectedVersion: string): Promise<void> {
 		return;
 	}
 	console.log(chalk.yellow(`\nWarning: ${formatVerificationFailure(result, expectedVersion)}`));
-	console.log(
-		chalk.yellow(
-			`You may need to reinstall: curl -fsSL https://raw.githubusercontent.com/can1357/gajae-code/main/scripts/install.sh | sh`,
-		),
-	);
+	console.log(chalk.yellow(formatManualUpdateInstructions()));
 }
 
 async function unlinkIfExists(filePath: string): Promise<void> {
@@ -314,8 +366,7 @@ async function updateViaBun(expectedVersion: string): Promise<void> {
  */
 async function updateViaBinaryAt(targetPath: string, expectedVersion: string): Promise<void> {
 	const binaryName = getBinaryName();
-	const tag = `v${expectedVersion}`;
-	const url = `https://github.com/${REPO}/releases/download/${tag}/${binaryName}`;
+	const url = buildReleaseBinaryUrl(expectedVersion);
 
 	const tempPath = `${targetPath}.new`;
 	const backupPath = `${targetPath}.bak`;
@@ -323,7 +374,7 @@ async function updateViaBinaryAt(targetPath: string, expectedVersion: string): P
 
 	const response = await fetch(url, { redirect: "follow" });
 	if (!response.ok || !response.body) {
-		throw new Error(`Download failed: ${response.statusText}`);
+		throw new Error(formatBinaryDownloadFailureMessage(binaryName, url, response.statusText || response.status));
 	}
 	const fileStream = fs.createWriteStream(tempPath, { mode: 0o755 });
 	await pipeline(response.body, fileStream);

package/src/config/settings-schema.ts

@@ -337,7 +337,7 @@ export const SETTINGS_SCHEMA = {
 
 	"theme.light": {
 		type: "string",
-		default: "light",
+		default: "blue-crab",
 		ui: {
 			tab: "appearance",
 			label: "Light Theme",
@@ -843,6 +843,26 @@ export const SETTINGS_SCHEMA = {
 				"Maximum wait between retries, in ms. When the provider asks us to wait longer than this and no credential or model fallback succeeds, the request fails fast instead of sleeping (e.g. 3-hour Anthropic rate-limit windows).",
 		},
 	},
+	"retry.requestMaxRetries": {
+		type: "number",
+		default: 5,
+		ui: {
+			tab: "model",
+			label: "Provider Request Retries",
+			description:
+				"Maximum provider request retries before a stream is established. Counts retries, not the first attempt. Set to 0 to disable provider request retries.",
+		},
+	},
+	"retry.streamMaxRetries": {
+		type: "number",
+		default: 5,
+		ui: {
+			tab: "model",
+			label: "Provider Stream Retries",
+			description:
+				"Maximum provider stream replay retries for replay-safe transient stream failures. Counts retries, not the first attempt. Set to 0 to disable provider stream retries.",
+		},
+	},
 	"retry.fallbackChains": { type: "record", default: {} as Record<string, string[]> },
 	"retry.fallbackRevertPolicy": {
 		type: "enum",
@@ -2510,6 +2530,7 @@ export const SETTINGS_SCHEMA = {
 		type: "enum",
 		values: [
 			"auto",
+			"duckduckgo",
 			"exa",
 			"brave",
 			"jina",
@@ -2534,7 +2555,12 @@ export const SETTINGS_SCHEMA = {
 				{
 					value: "auto",
 					label: "Auto",
-					description: "Preferred web-search provider",
+					description: "Active model's native search if its creds exist, else keyless DuckDuckGo",
+				},
+				{
+					value: "duckduckgo",
+					label: "DuckDuckGo",
+					description: "Keyless default — no API key or OAuth required",
 				},
 				{ value: "exa", label: "Exa", description: "Uses Exa API when EXA_API_KEY is set" },
 				{ value: "brave", label: "Brave", description: "Requires BRAVE_API_KEY" },
@@ -2833,6 +2859,8 @@ export interface RetrySettings {
 	maxRetries: number;
 	baseDelayMs: number;
 	maxDelayMs: number;
+	requestMaxRetries: number;
+	streamMaxRetries: number;
 }
 
 export interface MemoriesSettings {

package/src/config/settings.ts

@@ -5,7 +5,7 @@
  *   import { settings } from "./settings";
  *
  *   const enabled = settings.get("compaction.enabled");  // sync read
- *   settings.set("theme.dark", "titanium");               // sync write, saves in background
+ *   settings.set("theme.dark", "red-claw");              // sync write, saves in background
  *
  * For tests:
  *   const isolated = Settings.isolated({ "compaction.enabled": false });
@@ -17,6 +17,7 @@ import * as path from "node:path";
 import {
 	getAgentDbPath,
 	getAgentDir,
+	getCustomThemesDir,
 	getProjectDir,
 	isEnoent,
 	logger,
@@ -100,6 +101,14 @@ function setByPath(obj: RawSettings, segments: string[], value: unknown): void {
 }
 
 const PATH_SCOPED_ARRAY_SETTINGS = new Set<SettingPath>(["enabledModels", "disabledProviders"]);
+const LEGACY_THEME_NAME_REPLACEMENTS = {
+	dark: "red-claw",
+	light: "blue-crab",
+} as const;
+
+function isLegacyThemeName(name: string): name is keyof typeof LEGACY_THEME_NAME_REPLACEMENTS {
+	return name === "dark" || name === "light";
+}
 
 type PathScopedStringArrayEntry = {
 	path?: unknown;
@@ -587,6 +596,25 @@ export class Settings {
 		}
 	}
 
+	#hasCustomThemeFile(name: string): boolean {
+		try {
+			return fs.existsSync(path.join(getCustomThemesDir(this.#agentDir), `${name}.json`));
+		} catch {
+			return false;
+		}
+	}
+
+	#migrateLegacyBuiltInThemeName(name: string): string {
+		if (isLegacyThemeName(name) && !this.#hasCustomThemeFile(name)) {
+			return LEGACY_THEME_NAME_REPLACEMENTS[name];
+		}
+		return name;
+	}
+
+	#getThemeSlotForName(name: string): "dark" | "light" {
+		return isLightTheme(name, this.#agentDir) ? "light" : "dark";
+	}
+
 	/** Apply schema migrations to raw settings */
 	#migrateRawSettings(raw: RawSettings): RawSettings {
 		// queueMode -> steeringMode
@@ -606,13 +634,22 @@ export class Settings {
 		// Migrate old flat "theme" string to nested theme.dark/theme.light
 		if (typeof raw.theme === "string") {
 			const oldTheme = raw.theme;
-			if (oldTheme === "light" || oldTheme === "dark") {
-				// Built-in defaults — just remove, let new defaults apply
-				delete raw.theme;
+			const migratedTheme = this.#migrateLegacyBuiltInThemeName(oldTheme);
+			if (oldTheme === "dark" && migratedTheme === "red-claw") {
+				raw.theme = { dark: migratedTheme };
+			} else if (oldTheme === "light" && migratedTheme === "blue-crab") {
+				raw.theme = { light: migratedTheme };
 			} else {
-				// Custom theme — detect luminance to place in correct slot
-				const slot = isLightTheme(oldTheme) ? "light" : "dark";
-				raw.theme = { [slot]: oldTheme };
+				const slot = this.#getThemeSlotForName(migratedTheme);
+				raw.theme = { [slot]: migratedTheme };
+			}
+		} else if (raw.theme && typeof raw.theme === "object" && !Array.isArray(raw.theme)) {
+			const themeObj = raw.theme as Record<string, unknown>;
+			if (typeof themeObj.dark === "string") {
+				themeObj.dark = this.#migrateLegacyBuiltInThemeName(themeObj.dark);
+			}
+			if (typeof themeObj.light === "string") {
+				themeObj.light = this.#migrateLegacyBuiltInThemeName(themeObj.light);
 			}
 		}