Agent & model refactor (#478)

* agent & model refactor with ASKPASS git auth, UI restructure, clerk v7

Made-with: Cursor

* fix stale agent/effort refs, add tests for askpass + model resolution

- reviewCleanup.ts: payload.agent -> payload.model, remove effort
- selectMode.ts PlanEdit: remove delegation/subagent/effort references
- pullfrog.yml.ts: update env vars (drop GOOGLE_API_KEY/CURSOR_API_KEY,
  add GOOGLE_GENERATIVE_AI_API_KEY/XAI_API_KEY/MOONSHOT_API_KEY/OPENCODE_API_KEY)
- FlagsSettings/RepoInstructionsSection: remove stale effort/timeout copy
- new: gitAuthServer.test.ts (10 tests — lifecycle, token delivery, tamper detection, script gen)
- new: agent.test.ts (4 tests — default opentoad, AGENT_OVERRIDE, invalid override)
- new: models.test.ts (19 tests — parseModel, resolution, registry invariants)
- update models.dev snapshot

Made-with: Cursor

* fix changed-agents.sh to filter legacy agent files from CI matrix

legacy agent files (claude.ts, codex.ts, etc.) are @ts-nocheck and not
exported from index.ts. changed-agents.sh now reads index.ts imports to
build the active agent set and treats changes to inactive files as
non-agent changes (opentoad canary only).

Made-with: Cursor

* remove MCP file tools, old agent harnesses, and obsolete security tests

ASKPASS-based git auth makes the old MCP file tool security layer unnecessary:
- token never in subprocess env, so symlink/gitattributes/hook attacks can't exfiltrate it
- agents now use native file tools (OpenCode builtin read/edit)

deleted:
- action/mcp/file.ts (file_read, file_write, file_edit, file_delete, list_directory)
- action/mcp/index.ts (dead re-export)
- agent harnesses: claude.ts, codex.ts, cursor.ts, gemini.ts, opencode.ts
- opencode-runner.ts (inlined into opentoad.ts)
- security tests that validated MCP file tool restrictions
- commented-out three-step review flow (~300 lines)
- sanitizeSchema/wrapSchema dead code from mcp/shared.ts
- OPENCODE_MODEL_MINI/MAX env vars (effort-level model overrides removed)

updated test prompts to use generic file ops instead of MCP tool names.
restored pkg-json-scripts + requirements-txt-attack (test --ignore-scripts defense).

Made-with: Cursor

* bump actions/checkout v4 → v6 (node 24)

node 20 actions deprecated june 2, 2026.

Made-with: Cursor

* temporarily disable fail-fast on agnostic tests to debug checkout@v6

Made-with: Cursor

* re-enable fail-fast on agnostic tests

Made-with: Cursor

* fix test token mismatch: mint OIDC tokens scoped to target repo

CI tests override GITHUB_REPOSITORY to pullfrog/test-repo but inherit
the runner's GITHUB_TOKEN (scoped to pullfrog/app), causing 401s on
every run-context fetch. Clear GITHUB_TOKEN in the test subprocess so
ensureGitHubToken() mints a properly scoped token via OIDC.

Also centralizes the default GITHUB_REPOSITORY in runAgentStreaming
instead of repeating it in every test file, and fixes preview-cleanup
to remove workers from all queues (not just name-matching ones).

Made-with: Cursor

* fix ensureGitHubToken to try OIDC when app credentials are absent

ensureGitHubToken only attempted token minting when GITHUB_APP_ID and
GITHUB_PRIVATE_KEY were set. In CI, OIDC is available but app creds
aren't exposed — so the guard prevented minting entirely.

Made-with: Cursor

* dead code cleanup: remove remnants of deleted agents, file tools, effort system

remove unused @anthropic-ai/claude-agent-sdk and @openai/codex-sdk deps,
orphaned file-tool security tests, dead GEMINI_MODEL passthrough, stale
opencode-runner wiki refs, deleted test file references, and MCP file tool
docs. rename docs/effort → docs/models. fix vitest setup: move dotenv to
globalSetup (runs once before forks instead of per-file, 19s → 200ms).

Made-with: Cursor

* address review feedback: remove dead code, update stale references

- remove AGENT_OVERRIDE (only opentoad exists)
- remove shellToolName plumbing (always restricted shell)
- bump action version to 0.0.179
- remove CURSOR_API_KEY from all workflows/configs
- remove OPENCODE_MODEL_MINI/MAX from workflows/docs
- delete wiki/effort.md, rewrite docs/effort.mdx as "Models"
- rewrite wiki/modes.md: orchestrator/subagent → single agent
- simplify flag system: drop builtin flag extraction (debug, effort,
  timeout, agent), keep custom flag replacement only
- reserve all legacy flag names to prevent custom flag conflicts

Made-with: Cursor

* regenerate lockfile after removing claude-agent-sdk and codex-sdk

Made-with: Cursor

* fix import ordering, add lockfile check to pre-push hook

Made-with: Cursor

* remove dead debug payload field, stale packageExtensions

Made-with: Cursor

* merge proc-sandbox and token-exfil into a single test

proc-sandbox and token-exfil were duplicative — both tested that
SANDBOX_TEST_TOKEN couldn't be exfiltrated. consolidated into
token-exfil with shell:restricted (which actually exercises filterEnv)
and the /proc attack vector hints from proc-sandbox.

Made-with: Cursor

* fix wiki adversarial.md to match actual tokenExfil validator

Made-with: Cursor
This commit is contained in:
Colin McDonnell
2026-03-12 05:22:51 +00:00
committed by pullfrog[bot]
parent 5bcfae990a
commit 6d25adfd1a
111 changed files with 4196 additions and 10202 deletions
+3 -135
View File
@@ -1,4 +1,4 @@
import type { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
import type { StandardSchemaV1 } from "@standard-schema/spec";
import { encode as toonEncode } from "@toon-format/toon";
import type { FastMCP, Tool } from "fastmcp";
import { formatJsonValue, log } from "../utils/cli.ts";
@@ -61,141 +61,9 @@ export const execute = <T, R extends Record<string, any> | string>(
return _fn;
};
/**
* Sanitize JSON schema to remove problematic fields that Gemini CLI/API can't handle
* - Removes $schema field (causes "no schema with key or ref" errors)
* - Converts $defs to definitions (draft-07 compatibility)
* - Removes any draft-2020-12 specific features
* - Converts any_of with enum values to direct STRING enum (Google API requirement)
*/
function sanitizeSchema(schema: any): any {
if (!schema || typeof schema !== "object") {
return schema;
}
if (Array.isArray(schema)) {
return schema.map(sanitizeSchema);
}
// handle any_of with enum values - convert to direct STRING enum for Google API
// Google API requires: {type: "string", enum: [...]} not {anyOf: [{enum: [...]}, {enum: [...]}]}
if (schema.anyOf && Array.isArray(schema.anyOf) && schema.anyOf.length > 0) {
const enumValues: string[] = [];
let allAreEnumObjects = true;
for (const item of schema.anyOf) {
if (item && typeof item === "object" && Array.isArray(item.enum)) {
// collect enum values (only strings)
const stringEnums = item.enum.filter((v: any) => typeof v === "string");
if (stringEnums.length > 0) {
enumValues.push(...stringEnums);
} else {
allAreEnumObjects = false;
break;
}
} else {
allAreEnumObjects = false;
break;
}
}
// if all any_of items are enum objects with string values, convert to direct STRING enum
if (allAreEnumObjects && enumValues.length > 0) {
const uniqueEnums = [...new Set(enumValues)];
// preserve other properties from the original schema (like description)
const result: any = {
type: "string",
enum: uniqueEnums,
};
if (schema.description) {
result.description = schema.description;
}
return result;
}
}
const sanitized: any = {};
for (const [key, value] of Object.entries(schema)) {
// skip $schema field entirely
if (key === "$schema") {
continue;
}
// skip any_of if we already converted it above
if (key === "anyOf" && schema.anyOf) {
continue;
}
// convert $defs to definitions for draft-07 compatibility
if (key === "$defs") {
sanitized.definitions = sanitizeSchema(value);
continue;
}
// recursively sanitize nested objects
sanitized[key] = sanitizeSchema(value);
}
return sanitized;
}
/**
* Wrap a schema to sanitize its JSON Schema output for Gemini/OpenCode compatibility.
* xsschema calls ~standard.jsonSchema.input() for schemas that implement StandardJSONSchemaV1
* (i.e. have ~standard.jsonSchema), which includes arktype and our AJV-backed JSON schema wrapper.
* Schemas without ~standard.jsonSchema are returned unchanged (sanitization skipped).
*/
function wrapSchema(
schema: StandardSchemaV1<any> & {
"~standard": Partial<StandardJSONSchemaV1<any>["~standard"]>;
}
): StandardSchemaV1<any> {
const standardProps = schema["~standard"];
if (!("jsonSchema" in standardProps)) {
return schema;
}
const jsonSchema = standardProps.jsonSchema;
const wrapped: StandardSchemaV1<any> & StandardJSONSchemaV1<any> = {
...schema,
"~standard": {
...standardProps,
jsonSchema: {
input: (options) => sanitizeSchema(jsonSchema.input(options)),
output: (options) => sanitizeSchema(jsonSchema.output(options)),
},
},
};
return wrapped;
}
/**
* Transform tool to sanitize its parameter schema for Gemini CLI compatibility
*/
function sanitizeTool<T extends Tool<any, any>>(tool: T): T {
if (!tool.parameters) {
return tool;
}
const wrappedSchema = wrapSchema(tool.parameters);
// create a new tool with wrapped schema
return {
...tool,
parameters: wrappedSchema,
} as T;
}
export const addTools = (ctx: ToolContext, server: FastMCP<any>, tools: Tool<any, any>[]) => {
// sanitize schemas for gemini agent and opencode (when using Google API)
// both have issues with draft-2020-12 schemas and any_of enum constructs
const shouldSanitize = ctx.agent.name === "gemini" || ctx.agent.name === "opencode";
export const addTools = (_ctx: ToolContext, server: FastMCP<any>, tools: Tool<any, any>[]) => {
for (const tool of tools) {
const processedTool = shouldSanitize ? sanitizeTool(tool) : tool;
server.addTool(processedTool);
server.addTool(tool);
}
return server;
};