@gajae-code/coding-agent 0.17.1 → 0.17.4

package/src/cli/skills-cli.ts

@@ -8,7 +8,11 @@ import {
 	type EmbeddedDefaultGjcSkill,
 	getEmbeddedDefaultGjcSkills,
 } from "../defaults/gjc-defaults";
-import { discoverRuntimeSkills, type RuntimeSkillDiscoveryCandidate } from "../extensibility/runtime-skill-discovery";
+import {
+	discoverRuntimeSkills,
+	type RuntimeSkillDiscoveryCandidate,
+	SKILL_DISCOVERY_MAX_LIMIT,
+} from "../extensibility/runtime-skill-discovery";
 
 export type SkillsAction = "list" | "read" | "discover";
 
@@ -18,6 +22,11 @@ export interface SkillsCommandArgs {
 	flags?: {
 		json?: boolean;
 		source?: "all" | "project" | "user";
+		/** Max discover results; clamped to [1, SKILL_DISCOVERY_MAX_LIMIT] by the library. */
+		limit?: number;
+		/** Zero-based start of the discover page; normalized by the library. */
+		offset?: number;
+		query?: string;
 	};
 }
 
@@ -54,6 +63,25 @@ function formatCandidate(candidate: RuntimeSkillDiscoveryCandidate): string {
 	return `${candidate.name}\t${candidate.source}\t${candidate.description}\t${candidate.path}${useWhen}`;
 }
 
+/** Shell-quote only when needed, so a single-word query stays copy-pasteable as typed. */
+function quoteArg(value: string): string {
+	if (/^[\w.,:/@=+-]+$/.test(value)) return value;
+	return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+
+/**
+ * The continuation command, echoing back the filters the invocation carried so
+ * the printed line is runnable verbatim rather than a hint the user has to
+ * reassemble.
+ */
+function formatNextPageCommand(flags: SkillsCommandArgs["flags"], nextOffset: number): string {
+	const parts = ["gjc skills discover", `--offset ${nextOffset}`];
+	if (flags?.limit !== undefined) parts.push(`--limit ${flags.limit}`);
+	if (flags?.query) parts.push(`--query ${quoteArg(flags.query)}`);
+	if (flags?.source && flags.source !== "all") parts.push(`--source ${flags.source}`);
+	return parts.join(" ");
+}
+
 export async function runSkillsCommand(cmd: SkillsCommandArgs): Promise<void> {
 	if (cmd.action === "list") {
 		const skills = listEmbeddedSkills();
@@ -74,18 +102,34 @@ export async function runSkillsCommand(cmd: SkillsCommandArgs): Promise<void> {
 			const result = await discoverRuntimeSkills({
 				cwd: process.cwd(),
 				source,
+				query: cmd.flags?.query,
+				// A human paging the catalog defaults to the widest page the library
+				// serves; the library default stays sized for the agent tool's context.
+				limit: cmd.flags?.limit ?? SKILL_DISCOVERY_MAX_LIMIT,
+				offset: cmd.flags?.offset,
 				policy: {
 					...settings.getGroup("skills"),
 					disabledExtensions: settings.get("disabledExtensions"),
 				},
 			});
 			if (cmd.flags?.json) {
-				writeJson({ candidates: result.candidates, diagnostics: result.diagnostics.messages });
+				writeJson({
+					candidates: result.candidates,
+					scanned: result.scanned,
+					matching: result.matching,
+					offset: result.offset,
+					// Omitted, not null: absence is how the final page is reported.
+					...(result.nextOffset === undefined ? {} : { nextOffset: result.nextOffset }),
+					diagnostics: result.diagnostics.messages,
+				});
 				return;
 			}
 			for (const candidate of result.candidates) {
 				process.stdout.write(`${formatCandidate(candidate)}\n`);
 			}
+			if (result.nextOffset !== undefined) {
+				process.stdout.write(`\nNext page: ${formatNextPageCommand(cmd.flags, result.nextOffset)}\n`);
+			}
 			if (result.diagnostics.messages.length > 0) {
 				process.stdout.write("\nDiagnostics:\n");
 				for (const message of result.diagnostics.messages) {

package/src/cli.ts

@@ -1,14 +1,16 @@
 #!/usr/bin/env bun
 
+import type { CommandEntry } from "@gajae-code/utils/cli";
 /** Lightweight CLI bootstrap. Heavy command registration is loaded only after
  * security admission; `gjc doctor` stays reachable when normal startup breaks. */
-import { APP_NAME, formatBunRuntimeError, MIN_BUN_VERSION } from "@gajae-code/utils/dirs";
+import { APP_NAME, formatBunRuntimeError, MIN_BUN_VERSION, VERSION } from "@gajae-code/utils/dirs";
 import { startTiming } from "@gajae-code/utils/logger";
 import {
 	BASH_SHELL_RUNTIME_ARG,
 	BASH_SHELL_SUPERVISOR_ARG,
 	BASH_SHELL_WORKER_ARG,
 } from "./exec/bash-shell-worker-protocol";
+import { runSdkStderrDrainerFromArgv } from "./sdk/broker/stderr-drainer";
 
 const MANAGED_OWNER_SUPERVISOR_ARG = "--internal-managed-owner-supervisor";
 const MANAGED_OWNER_CHILD_TOKEN_ENV = "GJC_MANAGED_OWNER_CHILD_TOKEN";
@@ -28,6 +30,49 @@ if (Bun.semver.order(Bun.version, MIN_BUN_VERSION) < 0) {
 }
 process.title = APP_NAME;
 
+/** Public-family hooks kept available for private-worker tests without loading the full registry. */
+export const commands: CommandEntry[] = [
+	{ name: "sdk", load: () => import("./commands/sdk").then(module => module.default) },
+	{ name: "daemon", load: () => import("./commands/daemon").then(module => module.default) },
+];
+
+async function installRuntimeGlobals(writeNoFileWarning?: (text: string) => void): Promise<void> {
+	const { installH2Fetch } = await import("@gajae-code/ai/utils/h2-fetch");
+	// Activate HTTP/2 for all `fetch()` calls (provider streams, OAuth, model
+	// discovery, web tools). Bun's HTTP/2 client is gated on a startup flag we
+	// can't toggle from JS, so we patch globalThis.fetch to pass
+	// `protocol: "http2"` per request, with transparent HTTP/1.1 fallback on
+	// `HTTP2Unsupported`. See @gajae-code/ai/utils/h2-fetch for details.
+	installH2Fetch();
+
+	const { warnIfMacOSNoFileLimitTooLow } = await import("./cli/nofile-limit");
+	warnIfMacOSNoFileLimitTooLow({ writeStderr: writeNoFileWarning });
+
+	// Secondary in-process scrub of the macOS malloc-stack-logging vars. The real
+	// boundary is the darwin re-exec guard at the top of runCli(): Bun snapshots the
+	// spawn-default environment at startup, so deleting these here does NOT clean the
+	// env children inherit by default — it only tidies `process.env` for code that
+	// reads it directly. Kept as belt-and-braces for the rare re-exec-unavailable
+	// fallback; managed spawns already use filterProcessEnv and the native PTY lane
+	// strips them independently.
+	delete process.env.MallocStackLogging;
+	delete process.env.MallocStackLoggingNoCompact;
+}
+
+async function dispatchPublicFamily(argv: string[]): Promise<void> {
+	const family = argv[0];
+	if (family !== "sdk" && family !== "daemon") return;
+	const { dispatchPublicCommand } = await import("./cli/public-command-entry");
+	const load = commands.find(entry => entry.name === family)!.load;
+	await dispatchPublicCommand(argv.slice(1), {
+		bin: APP_NAME,
+		version: VERSION,
+		command: family,
+		load,
+		setup: report => installRuntimeGlobals(text => report({ code: "macos_nofile_limit_low", successStderr: text })),
+	});
+}
+
 function isDoctorArgv(argv: readonly string[]): boolean {
 	return argv[0] === "doctor";
 }
@@ -92,6 +137,21 @@ export async function runCli(argv: string[]): Promise<void> {
 			return;
 		}
 	}
+	if (argv[0] === "sdk" && argv[1] === "stderr-drain-internal") {
+		// Private lifecycle stderr drainer: must stay ahead of the public sdk family
+		// dispatcher, which would otherwise reject the private argv as a usage error.
+		try {
+			await runSdkStderrDrainerFromArgv(argv.slice(2));
+		} catch {
+			process.stderr.write("gjc sdk: invalid internal stderr drainer invocation\n");
+			process.exitCode = 2;
+		}
+		return;
+	}
+	if (argv[0] === "sdk" || argv[0] === "daemon") {
+		await dispatchPublicFamily(argv);
+		return;
+	}
 	if (argv.length === 1 && argv[0] === "--supports-macos-community-app") {
 		process.stdout.write("macos-community-app-offer\n");
 		return;

package/src/commands/daemon.ts

@@ -1,93 +1,89 @@
-/**
- * Manage GJC background daemons (status/list/stop/restart).
- */
-import { Args, CliParseError, Command, Flags } from "@gajae-code/utils/cli";
+/** Manage public daemon operations while keeping worker grammar private. */
+import {
+	type ArgDescriptor,
+	Args,
+	CliParseError,
+	Command,
+	type FlagDescriptor,
+	Flags,
+	type ParseOutput,
+} from "@gajae-code/utils/cli";
 import {
 	type DaemonCommandAction,
 	type DaemonCommandArgs,
 	isDaemonInternalAction,
 	runDaemonCommand,
 } from "../cli/daemon-cli";
+import { PublicCommandFailure } from "../cli/public-command-errors";
+import { getPublicCommand } from "../cli/public-command-registry";
 import type { DaemonKind } from "../daemon/control-types";
-import { DAEMON_ACTION_TOKENS, resolveDaemonAction } from "../daemon/operator-contract";
+import { resolveDaemonAction } from "../daemon/operator-contract";
 import { initTheme } from "../modes/theme/theme";
 
-const ACTIONS = [...DAEMON_ACTION_TOKENS, "discord-internal", "slack-internal"] as const;
-
-function parsePositiveTimeout(raw: string | undefined, flagName: string): number | undefined {
-	if (raw === undefined) return undefined;
-	if (!/^[0-9]+$/.test(raw)) {
-		throw new CliParseError(`Expected ${flagName} to be a positive safe integer, got "${raw}"`);
-	}
-	const value = Number(raw);
-	if (!Number.isSafeInteger(value) || value <= 0) {
-		throw new CliParseError(`Expected ${flagName} to be a positive safe integer, got "${raw}"`);
-	}
-	return value;
-}
-
 export default class Daemon extends Command {
-	static description =
-		"Manage GJC background daemons. Routine use: `gjc daemon status` to check, `gjc daemon restart` to reload (spawns one if none is running). `stop`/`list` and the escalation flags below are advanced primitives.";
-
-	static examples = [
-		"# Check the daemon (concise per-daemon result)\n  gjc daemon status",
-		"# Reload, spawning a fresh owner if none is running\n  gjc daemon restart",
-		"# Full runtime detail and the roots list\n  gjc daemon status --verbose",
-		"# Machine-readable output for automation\n  gjc daemon status --json",
-		"# Stop, hard-killing an unresponsive owner\n  gjc daemon stop --force",
-	];
-
-	static args = {
-		action: Args.string({
-			description: "Daemon action (status, restart, reload, stop, list)",
-			required: false,
-			options: [...ACTIONS] as string[],
-		}),
-		kind: Args.string({ description: "Daemon kind(s) to target", required: false, multiple: true }),
-	};
-
-	static flags = {
-		verbose: Flags.boolean({ char: "v", description: "Show runtime detail and the full roots list" }),
-		all: Flags.boolean({ description: "Target all registered daemon kinds" }),
-		json: Flags.boolean({ description: "Emit JSON output" }),
-		force: Flags.boolean({ description: "Allow hard-kill escalation when graceful stop times out" }),
-		"graceful-timeout-ms": Flags.string({ description: "Cooperative stop timeout before escalation" }),
-		"kill-timeout-ms": Flags.string({ description: "Wait for old pid death after SIGKILL" }),
-		"spawn-if-stopped": Flags.boolean({ description: "On restart, spawn even when no daemon is running" }),
-		smoke: Flags.boolean({ description: "Internal: run worker smoke without configuration or network" }),
-		"owner-id": Flags.string({ description: "Internal: daemon owner id" }),
-		"agent-dir": Flags.string({ description: "Internal: daemon state directory" }),
-	};
+	static description = getPublicCommand(["daemon"])!.description;
+	static args: Record<string, ArgDescriptor> = getPublicCommand(["daemon"])!.args;
+	static flags: Record<string, FlagDescriptor> = getPublicCommand(["daemon"])!.flags;
 
 	async run(): Promise<void> {
-		const { args, flags } = await this.parse(Daemon);
-		const rawAction = args.action ?? "status";
+		const internal = isDaemonInternalAction(this.argv[0] as DaemonCommandAction);
+		const resolved = resolveDaemonAction(this.argv[0]);
+		const action = (internal ? this.argv[0] : (resolved ?? "status")) as DaemonCommandAction;
+		const descriptor = getPublicCommand(["daemon", resolved ?? "status"])!;
+		class PublicDaemonOperation extends Daemon {
+			static args = { kind: { ...descriptor.args.kind!, options: undefined } };
+			static flags = descriptor.flags;
+		}
+		const parser = internal
+			? new DaemonWorker(this.argv, this.config)
+			: new PublicDaemonOperation(resolved ? this.argv.slice(1) : this.argv, this.config);
+		let parsed: ParseOutput;
+		try {
+			parsed = await parser.parse((internal ? DaemonWorker : PublicDaemonOperation) as typeof Daemon);
+		} catch (error) {
+			if (!internal && error instanceof CliParseError)
+				throw new PublicCommandFailure({ kind: "usage", proof: "pre-effect" });
+			throw error;
+		}
+		const { args, flags } = parsed;
+		const timeout = (name: string): number | undefined => {
+			const raw = flags[name];
+			if (raw === undefined) return undefined;
+			if (
+				typeof raw !== "string" ||
+				!/^[0-9]+$/.test(raw) ||
+				!Number.isSafeInteger(Number(raw)) ||
+				Number(raw) <= 0
+			) {
+				throw new PublicCommandFailure({ kind: "usage", proof: "pre-effect" });
+			}
+			return Number(raw);
+		};
 		const positional = Array.isArray(args.kind) ? args.kind : args.kind ? [args.kind] : [];
-		const flagRec = flags as Record<string, unknown>;
-		const gracefulTimeoutMs = parsePositiveTimeout(
-			flagRec["graceful-timeout-ms"] as string | undefined,
-			"--graceful-timeout-ms",
-		);
-		const killTimeoutMs = parsePositiveTimeout(flagRec["kill-timeout-ms"] as string | undefined, "--kill-timeout-ms");
-		const action = (resolveDaemonAction(rawAction) ?? rawAction) as DaemonCommandAction;
-		const kinds = positional as DaemonKind[];
 		const cmd: DaemonCommandArgs = {
 			action,
-			kinds,
+			kinds: positional as DaemonKind[],
 			all: Boolean(flags.all),
 			json: Boolean(flags.json),
 			force: Boolean(flags.force),
 			verbose: Boolean(flags.verbose),
-			gracefulTimeoutMs,
-			killTimeoutMs,
-			spawnIfStopped: flagRec["spawn-if-stopped"] as boolean | undefined,
+			gracefulTimeoutMs: timeout("graceful-timeout-ms"),
+			killTimeoutMs: timeout("kill-timeout-ms"),
+			spawnIfStopped: flags["spawn-if-stopped"] as boolean | undefined,
 			smoke: Boolean(flags.smoke),
-			ownerId: flagRec["owner-id"] as string | undefined,
-			agentDir: flagRec["agent-dir"] as string | undefined,
+			ownerId: flags["owner-id"] as string | undefined,
+			agentDir: flags["agent-dir"] as string | undefined,
 		};
-
-		if (!isDaemonInternalAction(action)) await initTheme();
+		if (!internal) await initTheme();
 		await runDaemonCommand(cmd);
 	}
 }
+
+class DaemonWorker extends Daemon {
+	static args = { action: Args.string({ required: true }), kind: Args.string({ multiple: true }) };
+	static flags = {
+		smoke: Flags.boolean({ description: "Run worker smoke without configuration or network" }),
+		"owner-id": Flags.string({ description: "Daemon owner id" }),
+		"agent-dir": Flags.string({ description: "Daemon state directory" }),
+	};
+}