@gajae-code/coding-agent 0.4.3 → 0.4.5

package/src/coordinator-mcp/policy.ts

@@ -0,0 +1,160 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+export type CoordinatorMutationClass = "sessions" | "questions" | "reports";
+
+export interface CoordinatorNamespace {
+	profile: string | null;
+	repo: string | null;
+}
+
+export interface CoordinatorMcpConfig {
+	allowedRoots: string[];
+	mutationClasses: Set<CoordinatorMutationClass>;
+	artifactByteCap: number;
+	namespace: CoordinatorNamespace;
+	stateRoot: string;
+	sessionCommand: string | null;
+}
+
+export interface CoordinatorMutationRequest {
+	allow_mutation?: boolean;
+}
+
+const DEFAULT_ARTIFACT_BYTE_CAP = 64 * 1024;
+const MAX_ARTIFACT_BYTE_CAP = 1024 * 1024;
+const MUTATION_CLASSES = new Set<CoordinatorMutationClass>(["sessions", "questions", "reports"]);
+const LEGACY_MUTATION_CLASS_ALIASES = new Map<string, CoordinatorMutationClass>([
+	["session", "sessions"],
+	["prompt", "sessions"],
+	["question", "questions"],
+	["report", "reports"],
+]);
+
+function parseList(value: string | undefined): string[] {
+	return (value ?? "")
+		.split(/[\n,;:]+/)
+		.map(part => part.trim())
+		.filter(Boolean);
+}
+
+function parseRootList(value: string | undefined): string[] {
+	const normalized = (value ?? "").replace(/[\n,;]+/g, path.delimiter);
+	return normalized
+		.split(path.delimiter)
+		.map(part => part.trim())
+		.filter(Boolean);
+}
+
+function parseMutationClasses(value: string | undefined): Set<CoordinatorMutationClass> {
+	const classes = new Set<CoordinatorMutationClass>();
+	for (const raw of parseList(value)) {
+		const normalized = raw.toLowerCase();
+		if (normalized === "all") {
+			for (const mutationClass of MUTATION_CLASSES) classes.add(mutationClass);
+			continue;
+		}
+		const mutationClass = LEGACY_MUTATION_CLASS_ALIASES.get(normalized) ?? normalized;
+		if (MUTATION_CLASSES.has(mutationClass as CoordinatorMutationClass))
+			classes.add(mutationClass as CoordinatorMutationClass);
+	}
+	return classes;
+}
+
+function parseByteCap(value: string | undefined): number {
+	const parsed = Number.parseInt(value ?? "", 10);
+	if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_ARTIFACT_BYTE_CAP;
+	return Math.min(parsed, MAX_ARTIFACT_BYTE_CAP);
+}
+
+function cleanScope(value: string | undefined): string | null {
+	const trimmed = value?.trim();
+	if (!trimmed) return null;
+	return trimmed.replace(/[^a-zA-Z0-9_.-]+/g, "-").slice(0, 100) || null;
+}
+
+export function buildCoordinatorMcpConfig(env: NodeJS.ProcessEnv = process.env): CoordinatorMcpConfig {
+	const stateRoot =
+		env.GJC_COORDINATOR_MCP_STATE_ROOT?.trim() || path.join(process.cwd(), ".gjc", "state", "coordinator-mcp");
+	return {
+		allowedRoots: parseRootList(env.GJC_COORDINATOR_MCP_WORKDIR_ROOTS).map(root => path.resolve(root)),
+		mutationClasses: parseMutationClasses(
+			env.GJC_COORDINATOR_MCP_MUTATIONS ?? env.GJC_COORDINATOR_MCP_ENABLE_MUTATION_CLASSES,
+		),
+		artifactByteCap: parseByteCap(
+			env.GJC_COORDINATOR_MCP_ARTIFACT_BYTE_CAP ?? env.GJC_COORDINATOR_MCP_ARTIFACT_MAX_BYTES,
+		),
+		namespace: {
+			profile: cleanScope(env.GJC_COORDINATOR_MCP_PROFILE),
+			repo: cleanScope(env.GJC_COORDINATOR_MCP_REPO),
+		},
+		stateRoot: path.resolve(stateRoot),
+		sessionCommand: env.GJC_COORDINATOR_MCP_SESSION_COMMAND?.trim() || null,
+	};
+}
+
+async function realpathIfExists(value: string): Promise<string> {
+	try {
+		return await fs.realpath(value);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+		const parent = await fs.realpath(path.dirname(value));
+		return path.join(parent, path.basename(value));
+	}
+}
+
+function isInside(candidate: string, root: string): boolean {
+	const relative = path.relative(root, candidate);
+	return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+async function canonicalAllowedRoots(config: CoordinatorMcpConfig): Promise<string[]> {
+	const roots = await Promise.all(config.allowedRoots.map(root => realpathIfExists(root)));
+	return roots.map(root => path.resolve(root));
+}
+
+export async function assertCoordinatorWorkdir(config: CoordinatorMcpConfig, cwd: unknown): Promise<string> {
+	if (typeof cwd !== "string" || cwd.trim().length === 0) throw new Error("coordinator_workdir_required");
+	if (config.allowedRoots.length === 0) throw new Error("coordinator_workdir_roots_required");
+	const requested = path.resolve(cwd);
+	const canonicalRequested = await realpathIfExists(requested);
+	const roots = await canonicalAllowedRoots(config);
+	if (!roots.some(root => isInside(canonicalRequested, root))) {
+		throw new Error(`coordinator_workdir_outside_allowed_roots:${requested}`);
+	}
+	return requested;
+}
+
+export async function assertCoordinatorArtifactPath(
+	config: CoordinatorMcpConfig,
+	artifactPath: unknown,
+): Promise<{ path: string; byteCap: number }> {
+	if (typeof artifactPath !== "string" || artifactPath.trim().length === 0)
+		throw new Error("coordinator_artifact_path_required");
+	if (config.allowedRoots.length === 0) throw new Error("coordinator_artifact_roots_required");
+	const requested = path.resolve(artifactPath);
+	const canonicalRequested = await realpathIfExists(requested);
+	const roots = await canonicalAllowedRoots(config);
+	if (!roots.some(root => isInside(canonicalRequested, root))) {
+		throw new Error(`coordinator_artifact_outside_allowed_roots:${requested}`);
+	}
+	return { path: requested, byteCap: config.artifactByteCap };
+}
+
+export function requireCoordinatorMutation(
+	config: CoordinatorMcpConfig,
+	mutationClass: CoordinatorMutationClass,
+	request: CoordinatorMutationRequest,
+): void {
+	if (!config.mutationClasses.has(mutationClass))
+		throw new Error(`coordinator_mutation_class_disabled:${mutationClass}`);
+	if (request.allow_mutation !== true) throw new Error(`coordinator_mutation_call_not_allowed:${mutationClass}`);
+}
+
+export function coordinatorNamespacePath(config: CoordinatorMcpConfig): string {
+	return path.join(
+		config.stateRoot,
+		config.namespace.profile ?? "unscoped-profile",
+		config.namespace.repo ?? "unscoped-repo",
+	);
+}

package/src/coordinator-mcp/safety.ts

@@ -0,0 +1,80 @@
+import {
+	assertCoordinatorArtifactPath,
+	assertCoordinatorWorkdir,
+	buildCoordinatorMcpConfig,
+	type CoordinatorMcpConfig,
+	type CoordinatorMutationClass,
+	requireCoordinatorMutation,
+} from "./policy";
+
+export const COORDINATOR_MUTATION_CLASSES = ["sessions", "questions", "reports"] as const;
+
+export type { CoordinatorMutationClass };
+
+export interface CoordinatorSafetyConfig {
+	allowedRoots: string[];
+	artifactMaxBytes: number;
+	enabledMutationClasses: Set<CoordinatorMutationClass>;
+	repo?: string;
+	profile?: string;
+}
+
+export interface CoordinatorSafetyPolicy {
+	config: CoordinatorSafetyConfig;
+	resolveWorkdir(input: unknown): Promise<string>;
+	resolveArtifactPath(input: unknown): Promise<string>;
+	assertMutationAllowed(
+		mutationClass: CoordinatorMutationClass,
+		args: Record<string, unknown>,
+	): { ok: true } | CoordinatorFailure;
+}
+
+export interface CoordinatorFailure {
+	ok: false;
+	reason: string;
+	[key: string]: unknown;
+}
+
+function toSafetyConfig(config: CoordinatorMcpConfig): CoordinatorSafetyConfig {
+	return {
+		allowedRoots: config.allowedRoots,
+		artifactMaxBytes: config.artifactByteCap,
+		enabledMutationClasses: config.mutationClasses,
+		repo: config.namespace.repo ?? undefined,
+		profile: config.namespace.profile ?? undefined,
+	};
+}
+
+function toFailure(error: unknown): CoordinatorFailure {
+	const message = error instanceof Error ? error.message : String(error);
+	const [rawReason, detail] = message.split(":", 2);
+	const reason = rawReason.replace(/^coordinator_/, "");
+	return detail === undefined ? { ok: false, reason } : { ok: false, reason, detail };
+}
+
+export async function createCoordinatorSafetyPolicy(
+	options: { env?: NodeJS.ProcessEnv } = {},
+): Promise<CoordinatorSafetyPolicy> {
+	const canonicalConfig = buildCoordinatorMcpConfig(options.env ?? process.env);
+	const config = toSafetyConfig(canonicalConfig);
+	return {
+		config,
+		resolveWorkdir(input: unknown): Promise<string> {
+			return assertCoordinatorWorkdir(canonicalConfig, input);
+		},
+		async resolveArtifactPath(input: unknown): Promise<string> {
+			return (await assertCoordinatorArtifactPath(canonicalConfig, input)).path;
+		},
+		assertMutationAllowed(
+			mutationClass: CoordinatorMutationClass,
+			args: Record<string, unknown>,
+		): { ok: true } | CoordinatorFailure {
+			try {
+				requireCoordinatorMutation(canonicalConfig, mutationClass, args);
+				return { ok: true };
+			} catch (error) {
+				return toFailure(error);
+			}
+		},
+	};
+}