@gajae-code/coding-agent 0.15.6 → 0.16.1

package/src/extensibility/extensions/runner.ts

@@ -69,6 +69,21 @@ interface BeforeAgentStartCombinedResult {
 	systemPrompt?: string[];
 }
 
+const BEFORE_AGENT_START_RESULT_KEYS = new Set(["message", "systemPrompt"]);
+const MAX_UNSUPPORTED_RESULT_FIELDS = 8;
+const MAX_RESULT_FIELD_NAME_LENGTH = 80;
+
+function unsupportedBeforeAgentStartResultFields(result: unknown): string[] {
+	if (result === null || typeof result !== "object" || Array.isArray(result)) return [];
+	const fields = Object.keys(result).filter(key => !BEFORE_AGENT_START_RESULT_KEYS.has(key));
+	const bounded = fields
+		.slice(0, MAX_UNSUPPORTED_RESULT_FIELDS)
+		.map(key => key.replace(/[^\x20-\x7e]/gu, "?").slice(0, MAX_RESULT_FIELD_NAME_LENGTH));
+	if (fields.length > MAX_UNSUPPORTED_RESULT_FIELDS)
+		bounded.push(`…and ${fields.length - MAX_UNSUPPORTED_RESULT_FIELDS} more`);
+	return bounded;
+}
+
 export type ExtensionErrorListener = (error: ExtensionError) => void;
 
 /** Bounded timeout for session_shutdown handlers — generous but never infinite. */
@@ -247,6 +262,7 @@ export class ExtensionRunner {
 	#getArtifactRangeFn: ExtensionContextActions["getArtifactRange"] = undefined;
 
 	#getJobsFn: ExtensionContextActions["getJobs"] = undefined;
+	#onJobFoldFn: ExtensionContextActions["onJobFold"] = undefined;
 	#sdkControlFn: ExtensionContextActions["sdkControl"] = undefined;
 	#setSdkPermissionProviderFn: ExtensionContextActions["setSdkPermissionProvider"] = undefined;
 	#setSdkClientBridgeFn: ExtensionContextActions["setSdkClientBridge"] = undefined;
@@ -378,6 +394,7 @@ export class ExtensionRunner {
 		this.#getArtifactRangeFn = contextActions.getArtifactRange;
 
 		this.#getJobsFn = contextActions.getJobs;
+		this.#onJobFoldFn = contextActions.onJobFold;
 		this.#sdkControlFn = contextActions.sdkControl;
 		this.#setSdkPermissionProviderFn = contextActions.setSdkPermissionProvider;
 		this.#setSdkClientBridgeFn = contextActions.setSdkClientBridge;
@@ -662,6 +679,7 @@ export class ExtensionRunner {
 			getArtifactRange: (id, offset, length) => this.#getArtifactRangeFn?.(id, offset, length),
 
 			getJobs: () => this.#getJobsFn?.(),
+			onJobFold: listener => this.#onJobFoldFn?.(listener) ?? (() => {}),
 			sdkControl: (operation, input) => this.#sdkControlFn?.(operation, input),
 			setSdkPermissionProvider: provider => this.#setSdkPermissionProviderFn?.(provider),
 			setSdkClientBridge: bridge => this.#setSdkClientBridgeFn?.(bridge),
@@ -679,6 +697,7 @@ export class ExtensionRunner {
 				...(this.#getExtensionsFn ? ["getExtensions"] : []),
 				...(this.#getArtifactRangeFn ? ["getArtifactRange"] : []),
 				...(this.#getJobsFn ? ["getJobs"] : []),
+				...(this.#onJobFoldFn ? ["onJobFold"] : []),
 				...(this.#sdkControlFn ? ["sdkControl"] : []),
 				...(this.#invokeSkillFn ? ["invokeSkill"] : []),
 				...(this.#setPlanModeFn ? ["setPlanMode"] : []),
@@ -1108,6 +1127,14 @@ export class ExtensionRunner {
 			const handlerResult = await this.#runHandlerWithTimeout(handler, event, ctx, ext, extensionHandlerTimeoutMs);
 
 			if (handlerResult) {
+				const unsupportedFields = unsupportedBeforeAgentStartResultFields(handlerResult);
+				if (unsupportedFields.length > 0) {
+					this.emitError({
+						extensionPath: ext.path,
+						event: "before_agent_start",
+						error: `Unsupported before_agent_start result field(s): ${unsupportedFields.join(", ")}. Supported fields: message, systemPrompt.`,
+					});
+				}
 				const result = handlerResult as BeforeAgentStartEventResult;
 				if (result.message) {
 					messages.push(result.message);

package/src/extensibility/extensions/types.ts

@@ -36,6 +36,7 @@ import type {
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@gajae-code/ai/utils/oauth/types";
 import type * as piCodingAgent from "@gajae-code/coding-agent";
 import type { AutocompleteItem, Component, EditorTheme, KeyId, TUI } from "@gajae-code/tui";
+import type { JobFoldEvent } from "../../async/job-manager";
 import type { KeybindingsManager } from "../../config/keybindings";
 import type { ModelRegistry } from "../../config/model-registry";
 import type { ModelSelectorValue } from "../../config/model-selector-value";
@@ -511,7 +512,7 @@ export interface ExtensionContext {
 	/** Run a control-surface mutation inside the session admission boundary. */
 	withSdkControlMutation?<T>(body: () => Promise<T>): Promise<T>;
 	cycleThinkingLevel(): ThinkingLevel | undefined;
-	setQueueMode(kind: "steering" | "follow_up" | "interrupt", mode: unknown): boolean;
+	setQueueMode(kind: "steering" | "follow_up" | "tool_interrupt", mode: unknown): boolean;
 	getSkillState(): unknown;
 	getConfigItems(): unknown;
 	getBranchCandidates(): unknown;
@@ -527,6 +528,8 @@ export interface ExtensionContext {
 		| Promise<{ bytes: Uint8Array; totalBytes: number } | undefined>;
 
 	getJobs(): unknown;
+	/** Subscribe to foreground-wait folds (`bash_folded`). Returns an unsubscribe function. */
+	onJobFold?(listener: (event: JobFoldEvent) => void): () => void;
 	/** Typed skill and mode controls exposed to the SDK host. */
 	invokeSkill?(
 		name: string,
@@ -1103,7 +1106,7 @@ export type { ToolResultEventResult } from "../shared-events";
 
 export interface BeforeAgentStartEventResult {
 	message?: Pick<CustomMessage, "customType" | "content" | "display" | "details" | "attribution">;
-	/** Replace the system prompt for this turn. If multiple extensions return this, they are chained. */
+	/** Replace the system prompt for this turn. To append, spread event.systemPrompt into the returned array. */
 	systemPrompt?: string[];
 }
 
@@ -1672,7 +1675,7 @@ export interface ExtensionContextActions {
 	getActiveModelProfile?: () => string | undefined;
 	withSdkControlMutation?: <T>(body: () => Promise<T>) => Promise<T>;
 	cycleThinkingLevel?: () => ThinkingLevel | undefined;
-	setQueueMode?: (kind: "steering" | "follow_up" | "interrupt", mode: unknown) => boolean;
+	setQueueMode?: (kind: "steering" | "follow_up" | "tool_interrupt", mode: unknown) => boolean;
 	getSkillState?: () => unknown;
 	getConfigItems?: () => unknown;
 	getBranchCandidates?: () => unknown;
@@ -1687,6 +1690,8 @@ export interface ExtensionContextActions {
 		| undefined
 		| Promise<{ bytes: Uint8Array; totalBytes: number } | undefined>;
 	getJobs?: () => unknown;
+	/** Subscribe to foreground-wait folds so the SDK host can publish `bash_folded`. Returns an unsubscribe. */
+	onJobFold?: (listener: (event: JobFoldEvent) => void) => () => void;
 	setSdkPermissionProvider?: (
 		provider:
 			| ((

package/src/extensibility/gjc-plugins/installer.ts

@@ -54,6 +54,11 @@ export type GjcBundleTransactionResult =
 const TAR_MAX_FILES = 8192;
 const TAR_MAX_FILE_BYTES = 16 * 1024 * 1024;
 const TAR_MAX_TOTAL_BYTES = 128 * 1024 * 1024;
+// Preserve the existing aggregate file budget plus the maximum per-entry
+// header/padding overhead and the two terminating TAR blocks.
+const TAR_MAX_ARCHIVE_BYTES = TAR_MAX_TOTAL_BYTES + TAR_MAX_FILES * 1024 + 1024;
+// A gzip stream can be slightly larger than its incompressible TAR payload.
+const TAR_MAX_COMPRESSED_BYTES = TAR_MAX_ARCHIVE_BYTES + 1024 * 1024;
 
 function scopeRoot(scope: GjcPluginScope, cwd: string): string {
 	return scope === "user" ? gjcPluginUserRoot() : gjcPluginProjectRoot(cwd);
@@ -95,6 +100,45 @@ export class GjcPluginSourceUnavailableError extends Error {
 	}
 }
 
+async function readTarballInput(tarPath: string, maxBytes: number): Promise<Buffer> {
+	let file: fs.FileHandle;
+	try {
+		file = await fs.open(tarPath, "r");
+	} catch {
+		throw new GjcPluginSourceUnavailableError();
+	}
+	try {
+		const stat = await file.stat();
+		if (!stat.isFile()) throw new GjcPluginSourceUnavailableError();
+		if (stat.size > maxBytes) {
+			throw new GjcPluginLoadError("security_policy", "GJC plugin tarball exceeds the archive input limit");
+		}
+		const raw = Buffer.allocUnsafe(stat.size);
+		let offset = 0;
+		while (offset < raw.byteLength) {
+			const { bytesRead } = await file.read(raw, offset, raw.byteLength - offset, offset);
+			if (bytesRead === 0) {
+				throw new GjcPluginLoadError("security_policy", "GJC plugin tarball changed while being read");
+			}
+			offset += bytesRead;
+		}
+		const probe = Buffer.allocUnsafe(1);
+		if ((await file.read(probe, 0, 1, offset)).bytesRead !== 0) {
+			throw new GjcPluginLoadError("security_policy", "GJC plugin tarball changed while being read");
+		}
+		return raw;
+	} catch (error) {
+		if (error instanceof GjcPluginLoadError || error instanceof GjcPluginSourceUnavailableError) throw error;
+		throw new GjcPluginSourceUnavailableError();
+	} finally {
+		await file.close().catch(() => {});
+	}
+}
+
+function isGunzipOutputLimitError(error: unknown): boolean {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ERR_BUFFER_TOO_LARGE";
+}
+
 interface ResolvedSource {
 	dir: string;
 	source: GjcPluginRegistrySource;
@@ -136,19 +180,15 @@ function tarHeaderChecksumOk(header: Uint8Array): boolean {
 
 /** Minimal, traversal/symlink-safe, resource-bounded extraction of a tar(.gz). */
 async function extractTarball(tarPath: string, destRoot: string): Promise<void> {
-	// A missing or corrupt archive surfaces as a native fs/zlib error. Translate
-	// it here so callers see the same typed source failure they get for every
-	// other unreachable source, instead of a raw errno escaping the lifecycle.
-	let raw: Buffer;
-	try {
-		raw = await fs.readFile(tarPath);
-	} catch {
-		throw new GjcPluginSourceUnavailableError();
-	}
+	const isGzip = /\.(tgz|tar\.gz)$/i.test(tarPath);
+	const raw = await readTarballInput(tarPath, isGzip ? TAR_MAX_COMPRESSED_BYTES : TAR_MAX_ARCHIVE_BYTES);
 	let buf: Buffer;
 	try {
-		buf = /\.(tgz|tar\.gz)$/i.test(tarPath) ? gunzipSync(raw) : raw;
-	} catch {
+		buf = isGzip ? gunzipSync(raw, { maxOutputLength: TAR_MAX_ARCHIVE_BYTES }) : raw;
+	} catch (error) {
+		if (isGunzipOutputLimitError(error)) {
+			throw new GjcPluginLoadError("security_policy", "GJC plugin tarball exceeds the expansion limit");
+		}
 		throw new GjcPluginLoadError("invalid_manifest", "GJC plugin tarball could not be decompressed");
 	}
 	const resolvedRoot = path.resolve(destRoot);

package/src/extensibility/runtime-skill-discovery.ts

@@ -1,13 +1,13 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { getTrustedHomeDir } from "@gajae-code/utils";
-import { findRepoRoot } from "../capability/fs";
+import { getPluginsDir, getTrustedHomeDir } from "@gajae-code/utils";
+import { findRepoRoot, invalidate as invalidateFsCache } from "../capability/fs";
 import type { Skill as CapabilitySkill } from "../capability/skill";
 import type { SkillsSettings } from "../config/settings-schema";
 import { resolveSkillScopeTrust } from "../config/skill-settings-defaults";
 import { scanClaudeProjectSkills, scanClaudeUserSkills } from "../discovery/claude";
 import { scanCodexProjectSkills, scanCodexUserSkills } from "../discovery/codex";
-import { compareSkillOrder, SOURCE_PATHS, scanSkillsFromDir } from "../discovery/helpers";
+import { compareSkillOrder, listClaudePluginRoots, SOURCE_PATHS, scanSkillsFromDir } from "../discovery/helpers";
 import { CANONICAL_GJC_WORKFLOW_SKILLS } from "../skill-state/canonical-skills";
 import { expandTilde } from "../tools/path-utils";
 import type { Skill } from "./skills";
@@ -234,6 +234,53 @@ function pushDiagnostic(diagnostics: string[], message: string): void {
 	if (diagnostics.length < MAX_DIAGNOSTICS) diagnostics.push(message);
 }
 
+async function collectPluginSkillDirs(
+	home: string,
+	cwd: string,
+): Promise<Array<{ dir: string; pluginName: string; level: "user" | "project" }>> {
+	// Ensure the underlying installed_plugins.json fs cache is current — install/upgrade
+	// writers already invalidate via clearPluginRootsAndCaches; this is a defensive
+	// fallback so a stale in-memory cache cannot mask a disabled/removed plugin.
+	invalidateFsCache(`${getPluginsDir(home)}/installed_plugins.json`);
+	try {
+		const { roots } = await listClaudePluginRoots(home, cwd);
+		return roots.map(root => ({
+			dir: `${root.path}/skills`,
+			pluginName: root.plugin,
+			level: root.scope,
+		}));
+	} catch {
+		return [];
+	}
+}
+
+async function diagnoseCustomDir(expandedDir: string, diagnostics: string[]): Promise<boolean> {
+	try {
+		const stat = await fs.lstat(expandedDir);
+		if (stat.isSymbolicLink()) {
+			try {
+				await fs.stat(expandedDir);
+			} catch {
+				pushDiagnostic(
+					diagnostics,
+					`skills.customDirectories entry "${expandedDir}" is a dangling symlink (target missing, likely a purged plugin cache dir); fix or remove it`,
+				);
+				return true;
+			}
+		}
+		return false;
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+			pushDiagnostic(
+				diagnostics,
+				`skills.customDirectories entry "${expandedDir}" does not exist (missing directory, likely a purged plugin cache dir); fix or remove it`,
+			);
+			return true;
+		}
+		return false;
+	}
+}
+
 async function scanProjectOrUserDir(
 	ctx: { cwd: string; home: string; repoRoot: string | null },
 	dir: string,
@@ -376,6 +423,44 @@ export async function discoverRuntimeSkills(
 		}
 	}
 
+	// Marketplace plugin skills: version-stable, enabled-only.
+	// Uses the same trust gate as native user/project scopes and the same
+	// discovery root (<installPath>/skills) the capability provider uses,
+	// namespaced as `plugin:skillName`.
+	if (policy?.enabled === true) {
+		const pluginDirs = await collectPluginSkillDirs(home, options.cwd);
+		for (const entry of pluginDirs) {
+			if (entry.level === "project" && !(source === "all" || source === "project")) continue;
+			if (entry.level === "user" && !(source === "all" || source === "user")) continue;
+			if (!sourceEnabled(entry.level, policy)) continue;
+			const label = `plugin ${entry.pluginName} skills`;
+			scanJobs.push(
+				(async () => {
+					const pluginCtx = { cwd: options.cwd, home, repoRoot: home };
+					const result = await scanSkillsFromDir(pluginCtx, {
+						dir: entry.dir,
+						providerId: "plugin",
+						level: entry.level,
+						requireDescription: true,
+					});
+					for (const skill of result.items) {
+						skill.name = `${entry.pluginName}:${skill.name}`;
+					}
+					return {
+						items: result.items.map(skill => ({ skill, source: entry.level as RuntimeSkillDiscoverySource })),
+						warnings: result.warnings ?? [],
+						label,
+					};
+				})(),
+			);
+		}
+	}
+	if (policy?.enabled === true && policy.customDirectories && policy.customDirectories.length > 0) {
+		for (const dir of getCustomSkillDirs(policy, home)) {
+			await diagnoseCustomDir(dir, diagnostics);
+		}
+	}
+
 	const settled = await Promise.all(scanJobs.map(job => job.catch(error => ({ error: String(error), label: "" }))));
 
 	const seenNames = new Set<string>();
@@ -470,6 +555,28 @@ export async function findRuntimeSkillByName(
 			);
 		}
 	}
+	if (policy?.enabled === true) {
+		try {
+			const pluginDirs = await collectPluginSkillDirs(home, cwd);
+			for (const entry of pluginDirs) {
+				if (!sourceEnabled(entry.level, policy)) continue;
+				scanJobs.push(
+					scanSkillsFromDir(
+						{ cwd, home, repoRoot: home },
+						{
+							dir: entry.dir,
+							providerId: "plugin",
+							level: entry.level,
+							requireDescription: true,
+						},
+					).then(result => {
+						for (const skill of result.items) skill.name = `${entry.pluginName}:${skill.name}`;
+						return result.items.map(skill => ({ skill, source: entry.level as RuntimeSkillDiscoverySource }));
+					}),
+				);
+			}
+		} catch {}
+	}
 	for (const entry of (await Promise.all(scanJobs)).flat()) {
 		if (entry.skill.name === normalized && isAllowedByPolicy(entry.skill, policy, [])) {
 			return toRuntimeSkill(entry.skill, entry.source);

package/src/extensibility/skills.ts

@@ -122,7 +122,7 @@ export interface LoadSkillsOptions extends SkillsSettings {
  */
 const LOADABLE_SKILL_PROVIDERS = new Set(["native"]);
 
-const BUILT_IN_SKILL_NAMES = new Set<string>(CANONICAL_GJC_WORKFLOW_SKILLS);
+const BUILT_IN_SKILL_NAMES = new Set<string>(CANONICAL_GJC_WORKFLOW_SKILLS.map(name => name.toLowerCase()));
 
 /**
  * Load skills from all configured locations.
@@ -235,21 +235,22 @@ export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadS
 		// workflow-routing hijack: warn, and let the session merge keep the bundled
 		// definition authoritative (sdk/session.ts). User-scope copies are not
 		// warned about: installed defaults legitimately mirror bundled skills.
-		if (capSkill.level === "project" && BUILT_IN_SKILL_NAMES.has(capSkill.name)) {
+		if (capSkill.level === "project" && BUILT_IN_SKILL_NAMES.has(capSkill.name.toLowerCase())) {
 			collisionWarnings.push({
 				skillPath: capSkill.path,
 				message: `name collision: "${capSkill.name}" is a bundled GJC workflow skill; the bundled definition takes precedence in sessions and this project copy is never used`,
 			});
 		}
 
-		const existing = skillMap.get(capSkill.name);
+		const skillKey = capSkill.name.toLowerCase();
+		const existing = skillMap.get(skillKey);
 		if (existing) {
 			collisionWarnings.push({
 				skillPath: capSkill.path,
 				message: `name collision: "${capSkill.name}" already loaded from ${existing.filePath}, skipping this one`,
 			});
 		} else {
-			skillMap.set(capSkill.name, {
+			skillMap.set(skillKey, {
 				name: capSkill.name,
 				description: typeof capSkill.frontmatter?.description === "string" ? capSkill.frontmatter.description : "",
 				filePath: capSkill.path,
@@ -318,14 +319,15 @@ export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadS
 		const resolvedPath = customRealPaths[i];
 		if (realPathSet.has(resolvedPath)) continue;
 
-		const existing = skillMap.get(skill.name);
+		const skillKey = skill.name.toLowerCase();
+		const existing = skillMap.get(skillKey);
 		if (existing) {
 			collisionWarnings.push({
 				skillPath: skill.filePath,
 				message: `name collision: "${skill.name}" already loaded from ${existing.filePath}, skipping this one`,
 			});
 		} else {
-			skillMap.set(skill.name, skill);
+			skillMap.set(skillKey, skill);
 			realPathSet.add(resolvedPath);
 		}
 	}
@@ -358,7 +360,7 @@ export function getSkillSlashCommandName(skill: Pick<Skill, "name">): string {
 }
 
 export function isNamespacedSkillSlashCommandName(commandName: string): boolean {
-	return commandName.startsWith("skill:");
+	return commandName.toLowerCase().startsWith("skill:");
 }
 
 export function getSkillSlashCommandNames(skill: Pick<Skill, "name">): string[] {
@@ -366,7 +368,7 @@ export function getSkillSlashCommandNames(skill: Pick<Skill, "name">): string[]
 }
 
 export function isSkillSlashCommandName(commandName: string, skill: Pick<Skill, "name">): boolean {
-	return commandName === getSkillSlashCommandName(skill);
+	return commandName.toLowerCase() === getSkillSlashCommandName(skill).toLowerCase();
 }
 
 export interface ResolvedSkillSlashCommand {
@@ -410,12 +412,19 @@ export function parseSkillInvocations(
 ): ParsedSkillInvocation[] {
 	const trimmedText = text.trim();
 	if (!trimmedText) return [];
-	const canonicalSkillCommandPattern = /(^|\s)\/(skill:[^\s]+)/g;
+	const normalizedSkillsByCommandName = new Map<string, Skill>();
+	for (const [commandName, skill] of skillsByCommandName) {
+		const normalizedCommandName = commandName.toLowerCase();
+		if (!normalizedSkillsByCommandName.has(normalizedCommandName)) {
+			normalizedSkillsByCommandName.set(normalizedCommandName, skill);
+		}
+	}
+	const canonicalSkillCommandPattern = /(^|\s)\/(skill:[^\s]+)/gi;
 	const matches: SkillTokenMatch[] = [];
 	for (const match of trimmedText.matchAll(canonicalSkillCommandPattern)) {
 		const commandName = match[2];
 		if (!commandName) continue;
-		const skill = skillsByCommandName.get(commandName);
+		const skill = normalizedSkillsByCommandName.get(commandName.toLowerCase());
 		if (!skill) continue;
 		const leading = match[1] ?? "";
 		const index = (match.index ?? 0) + leading.length;
@@ -458,10 +467,11 @@ export function resolveSkillSlashCommands(
 	for (const skill of skills) {
 		if (skill.hide === true) continue;
 		for (const name of getSkillSlashCommandNames(skill)) {
-			if (claimedNames.has(name)) {
+			const normalizedName = name.toLowerCase();
+			if (claimedNames.has(normalizedName)) {
 				continue;
 			}
-			claimedNames.add(name);
+			claimedNames.add(normalizedName);
 			commands.push({ name, description: skill.description, skill });
 		}
 	}