🛫 feat: Enable Full Access for BYOM Coding (#15718)

* feat: Enable Full Access for BYOM Coding 🛫

* test: Preserve endpoint policy under Full Access

* fix: Gate Full Access on expected root agent metadata
This commit is contained in:
Danny Avila 2026-09-07 22:46:01 -04:00 • committed by GitHub
parent cdc3339a78
commit 5ca1093ed9
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
16 changed files with 368 additions and 29 deletions

View file

@ -1,4 +1,4 @@
import { ShieldCheck, Hand } from 'lucide-react';
import { ShieldCheck, ShieldAlert, Hand } from 'lucide-react';
import {
Button,
DropdownMenu,
@ -32,7 +32,14 @@ export default function CodeApprovalMenu({
const labels: Record<CodeApprovalMode, string> = {
ask: localize('com_ui_code_approval_ask'),
acceptEdits: localize('com_ui_code_approval_accept_edits'),
fullAccess: localize('com_ui_code_approval_full_access'),
};
const descriptions: Record<CodeApprovalMode, string> = {
ask: localize('com_ui_code_approval_ask_description'),
acceptEdits: localize('com_ui_code_approval_accept_edits_description'),
fullAccess: localize('com_ui_code_approval_full_access_description'),
};
const ModeIcon = { ask: Hand, acceptEdits: ShieldCheck, fullAccess: ShieldAlert }[selected];
return (
<DropdownMenu>
@ -46,7 +53,7 @@ export default function CodeApprovalMenu({
className="h-8 gap-1.5 rounded-full px-2 text-text-secondary"
data-testid="code-approval-mode"
>
{selected === 'ask' ? <Hand aria-hidden="true" /> : <ShieldCheck aria-hidden="true" />}
<ModeIcon aria-hidden="true" />
<span>{labels[selected]}</span>
</Button>
</DropdownMenuTrigger>
@ -67,13 +74,7 @@ export default function CodeApprovalMenu({
<DropdownMenuRadioItem key={mode} value={mode}>
<div>
<div>{labels[mode]}</div>
<div className="text-xs text-text-tertiary">
{localize(
mode === 'ask'
? 'com_ui_code_approval_ask_description'
: 'com_ui_code_approval_accept_edits_description',
)}
</div>
<div className="text-xs text-text-tertiary">{descriptions[mode]}</div>
</div>
</DropdownMenuRadioItem>
))}

View file

@ -56,4 +56,26 @@ describe('CodeApprovalMenu', () => {
);
expect(screen.queryByTestId('code-approval-mode')).not.toBeInTheDocument();
});
test('selects full access on the conversation with sandbox scope explained', async () => {
mockUseCodeApprovalMode.mockReturnValue({
available: true,
modes: ['ask', 'acceptEdits', 'fullAccess'],
selected: 'ask',
});
render(
<CodeApprovalMenu
conversation={conversation}
setConversation={mockSetConversation}
disabled={false}
/>,
);
await userEvent.click(screen.getByTestId('code-approval-mode'));
expect(screen.getByText('com_ui_code_approval_full_access_description')).toBeInTheDocument();
await userEvent.click(screen.getByText('com_ui_code_approval_full_access'));
expect(mockSetConversation.mock.calls[0][0](conversation)).toEqual({
...conversation,
codeApprovalMode: 'fullAccess',
});
});
});

View file

@ -68,6 +68,101 @@ describe('useCodeApprovalMode', () => {
});
});
test.each(['permitted', 'restricted', 'missing'])(
'full access requires every reachable machine: %s',
(policy) => {
const permissions = {
fileWrite: { allowed: ['ask', 'allow'], default: 'ask' },
commandExecution: { allowed: ['ask', 'allow'], default: 'ask' },
};
mockUseAgentToolPermissions.mockReturnValue({
agent: {
id: 'agent-1',
tools: ['execute_code'],
stateful_code_sessions: true,
code_environment_id: 'mac',
subagents: { enabled: true, agent_ids: ['child'] },
},
});
mockUseAgentsMapContext.mockReturnValue(
policy === 'missing'
? {}
: {
child: {
id: 'child',
tools: ['execute_code'],
stateful_code_sessions: true,
code_environment_id: 'child-machine',
},
},
);
mockUseGetAgentsConfig.mockReturnValue({
agentsConfig: {
statefulCodeSessions: {
approvalsEnabled: true,
approvalModes: ['ask', 'acceptEdits', 'fullAccess'],
environments: [
{ id: 'mac', type: 'attached', configSchema: { permissions } },
{
id: 'child-machine',
type: 'attached',
configSchema: { permissions: policy === 'permitted' ? permissions : {} },
},
],
},
},
});
const { result } = renderHook(() =>
useCodeApprovalMode({ ...conversation, codeApprovalMode: 'fullAccess' }),
);
expect(result.current.modes.includes('fullAccess')).toBe(policy === 'permitted');
expect(result.current.selected).toBe(policy === 'permitted' ? 'fullAccess' : 'ask');
},
);
test.each(['agent-1', 'agent-2'])(
'waits for unresolved root %s before full access',
(missingId) => {
const permissions = {
fileWrite: { allowed: ['ask', 'allow'], default: 'ask' },
commandExecution: { allowed: ['ask', 'allow'], default: 'ask' },
};
mockUseGetAgentsConfig.mockReturnValue({
agentsConfig: {
statefulCodeSessions: {
approvalsEnabled: true,
approvalModes: ['ask', 'acceptEdits', 'fullAccess'],
environments: [{ id: 'mac', type: 'attached', configSchema: { permissions } }],
},
},
});
let loaded = false;
mockUseAgentToolPermissions.mockImplementation((id?: string) => ({
agent:
id === missingId && !loaded
? undefined
: {
id,
tools: ['execute_code'],
stateful_code_sessions: true,
code_environment_id: 'mac',
},
}));
const { result, rerender } = renderHook(() =>
useCodeApprovalMode(
{ ...conversation, codeApprovalMode: 'fullAccess' },
{ ...conversation, agent_id: 'agent-2' },
),
);
expect(result.current.modes).not.toContain('fullAccess');
expect(result.current.selected).toBe('ask');
loaded = true;
rerender();
expect(result.current.modes).toContain('fullAccess');
expect(result.current.selected).toBe('fullAccess');
},
);
test('falls back to ask when a saved mode is no longer permitted', () => {
mockUseGetAgentsConfig.mockReturnValue({
agentsConfig: {

View file

@ -27,18 +27,30 @@ export default function useCodeApprovalMode(
| TConfig['statefulCodeSessions']
| undefined;
const environments = statefulCodeSessions?.environments;
const attachedEnvironments = useMemo(
const reachable = useMemo(
() =>
collectReachableAgents([primaryAgent, addedAgent], agentsMap)
collectReachableAgents([primaryAgent, addedAgent], agentsMap, [
conversation?.agent_id,
addedConversation?.agent_id,
]),
[addedAgent, agentsMap, primaryAgent, conversation?.agent_id, addedConversation?.agent_id],
);
const codeEnvironments = useMemo(
() =>
reachable.agents
.filter(
(agent) =>
agent.stateful_code_sessions === true && agent.tools?.includes(Tools.execute_code),
)
.map((agent) => findExecutionEnvironment(agent, environments))
.filter(
(environment): environment is TPublicCodeEnvironment => environment?.type === 'attached',
),
[addedAgent, agentsMap, environments, primaryAgent],
.map((agent) => findExecutionEnvironment(agent, environments)),
[environments, reachable],
);
const attachedEnvironments = useMemo(
() =>
codeEnvironments.filter(
(environment): environment is TPublicCodeEnvironment => environment?.type === 'attached',
),
[codeEnvironments],
);
const supported =
(conversation?.endpointType ?? conversation?.endpoint) === EModelEndpoint.agents &&
@ -49,6 +61,10 @@ export default function useCodeApprovalMode(
const modes = useMemo(() => {
if (!available) return [];
const allowed = new Set<CodeApprovalMode>(endpointModes?.includes('ask') ? ['ask'] : []);
let fullAccessAllowed =
endpointModes?.includes('fullAccess') === true &&
reachable.complete &&
codeEnvironments.every((environment) => environment != null);
for (const environment of attachedEnvironments) {
const environmentModes = getAllowedCodeApprovalModes({
environment: 'attached',
@ -59,9 +75,11 @@ export default function useCodeApprovalMode(
if (endpointModes?.includes('acceptEdits') && environmentModes.includes('acceptEdits')) {
allowed.add('acceptEdits');
}
fullAccessAllowed &&= environmentModes.includes('fullAccess');
}
if (fullAccessAllowed) allowed.add('fullAccess');
return CODE_APPROVAL_MODES.filter((mode) => allowed.has(mode));
}, [attachedEnvironments, available, endpointModes]);
}, [attachedEnvironments, available, codeEnvironments, endpointModes, reachable.complete]);
const requested = conversation?.codeApprovalMode ?? 'ask';
/**
* Fail closed while agent/environment metadata is incomplete. An affirmative
@ -86,10 +104,17 @@ function findExecutionEnvironment(
: environments?.find((candidate) => candidate.default === true);
}
function collectReachableAgents(roots: Array<Agent | undefined>, agentsMap?: TAgentsMap): Agent[] {
function collectReachableAgents(
roots: Array<Agent | undefined>,
agentsMap: TAgentsMap | undefined,
expectedRootIds: Array<string | undefined | null>,
): { agents: Agent[]; complete: boolean } {
const pending = roots.filter((agent): agent is Agent => agent != null);
const visited = new Set<string>();
const agents: Agent[] = [];
let complete = expectedRootIds.every(
(id) => id == null || roots.some((agent) => agent?.id === id),
);
while (pending.length > 0) {
const agent = pending.pop();
if (agent == null || visited.has(agent.id)) continue;
@ -107,7 +132,8 @@ function collectReachableAgents(roots: Array<Agent | undefined>, agentsMap?: TAg
for (const id of ids) {
const candidate = agentsMap?.[id];
if (candidate != null) pending.push(candidate);
else complete = false;
}
}
return agents;
return { agents, complete };
}

View file

@ -4,6 +4,8 @@
"com_ui_code_approval_ask_description": "Ask before editing files or running commands",
"com_ui_code_approval_accept_edits": "Accept edits",
"com_ui_code_approval_accept_edits_description": "Allow file edits; continue asking before commands",
"com_ui_code_approval_full_access": "Full access",
"com_ui_code_approval_full_access_description": "Allow file edits and commands on your machine without asking. Sandbox limits and required approvals still apply.",
"com_ui_review_action": "Review 1 action",
"com_ui_review_actions": "Review {{0}} actions",
"com_ui_review_run_command": "Run command",

View file

@ -40,6 +40,8 @@ do not relax that policy to make the test pass.
6. Rejected creation leaves no file, and creation has no side effect before approval.
7. Selecting worker B does not expose worker A's file; B's write leaves A unchanged.
8. Stopping B produces a persisted tool failure, not success or fallback to A.
9. Selecting **Full access** runs commands and physically creates a file without
approval prompts, survives reload, and can switch back to **Ask before changes**.
Assertions inspect **tool outputs**, not echoed arguments or the model's final prose.
The default hosted Code API URL is deliberately pointed at an invalid local route,
@ -52,7 +54,8 @@ and workspaces. Ports are dynamically assigned, not the usual development ports.
Listeners are loopback-only. No existing database, launchd worker, pairing, or project
directory is reused. Children receive an allowlisted environment; checkout `.env`
keys are neutralized. Mutations default to real UI approval; the test explicitly selects
**Accept edits** for one file edit, while commands remain approval-gated and reads are allowed.
**Accept edits** for one file edit, then **Full access** for unattended commands and
file creation. Returning to **Ask before changes** restores approval prompts.
The command stops its children on success, failure, SIGINT, and SIGTERM. The private
temporary run directory is printed and retained for debugging; it contains test-only

View file

@ -14,6 +14,10 @@ module.exports = (run, context) => {
{ path: 'workspace/proof.txt', old_text: 'native-original', new_text: 'native-edited' },
],
read: ['read_file', { path: 'workspace/proof.txt' }],
fullCreate: [
'create_file',
{ path: 'workspace/unattended.txt', content: 'native-unattended', overwrite: false },
],
reject: [
'create_file',
{ path: 'workspace/rejected.txt', content: 'must-not-exist', overwrite: false },

View file

@ -41,7 +41,7 @@ test('native BYOM saves, persists, isolates workers, and fails closed', async ({
const cli = process.env.BYOM_CODE_CLI!;
const workers: Worker[] = [];
let selectedWorker: Worker;
let selectedApprovalMode: 'ask' | 'acceptEdits' = 'ask';
let selectedApprovalMode: 'ask' | 'acceptEdits' | 'fullAccess' = 'ask';
const password = `Acceptance-${randomUUID()}`;
const email = `native-${randomUUID()}@example.com`;
const registered = await page.request.post('/api/auth/register', {
@ -219,14 +219,19 @@ test('native BYOM saves, persists, isolates workers, and fails closed', async ({
return outputs.join('\n');
}
async function selectApprovalMode(mode: 'Ask before changes' | 'Accept edits') {
async function selectApprovalMode(mode: 'Ask before changes' | 'Accept edits' | 'Full access') {
const selector = page.getByTestId('code-approval-mode');
await expect(selector).toBeVisible();
await selector.click();
await expect(selector).toHaveAttribute('aria-expanded', 'true');
await page.getByRole('menuitemradio', { name: new RegExp(`^${mode}`) }).click();
await expect(selector).toContainText(mode, { timeout: 10_000 });
selectedApprovalMode = mode === 'Accept edits' ? 'acceptEdits' : 'ask';
const modes = {
'Full access': 'fullAccess',
'Accept edits': 'acceptEdits',
'Ask before changes': 'ask',
} as const;
selectedApprovalMode = modes[mode];
}
try {
@ -242,6 +247,13 @@ test('native BYOM saves, persists, isolates workers, and fails closed', async ({
expect(await turn('read')).toContain('native-edited');
/** Accept edits does not weaken command execution approval. */
expect(await turn('command', 'Approve')).toContain('native-command-ok');
await selectApprovalMode('Full access');
expect(await turn('command')).toContain('native-command-ok');
await turn('fullCreate');
expect(await readFile(path.join(a.root, 'unattended.txt'), 'utf8')).toBe('native-unattended');
await page.reload();
await expect(page.getByTestId('code-approval-mode')).toContainText('Full access');
expect(await turn('command')).toContain('native-command-ok');
await selectApprovalMode('Ask before changes');
expect(await turn('reject', 'Reject')).toMatch(/blocked|reject|denied|declined/i);
expect(await readdir(a.root)).not.toContain('rejected.txt');
@ -266,6 +278,9 @@ test('native BYOM saves, persists, isolates workers, and fails closed', async ({
physicalCreate: true,
acceptEditsWithoutPrompt: true,
commandsStillRequireApproval: true,
fullAccessCommandsWithoutPrompt: true,
fullAccessWritesWithoutPrompt: true,
fullAccessSurvivesReload: true,
crossTurnEdit: true,
rejectedWriteAbsent: true,
twoWorkerIsolation: true,

View file

@ -175,7 +175,7 @@ try {
configSchema: {
permissions: {
fileWrite: { allowed: ['ask', 'allow'], default: 'ask' },
commandExecution: { allowed: ['ask'], default: 'ask' },
commandExecution: { allowed: ['ask', 'allow'], default: 'ask' },
},
},
},

View file

@ -628,6 +628,10 @@ endpoints:
# allowed: [allow, ask, deny]
# default: ask
# commandExecution:
# # Add allow to offer Full access in the chat composer. Both
# # permission categories must permit allow; defaults can stay ask.
# # Full access skips routine code prompts within the worker sandbox.
# # Explicit endpoint ask/deny rules and hooks still apply.
# allowed: [ask, deny]
# default: ask
# pairing:

View file

@ -13,6 +13,95 @@ import { canAgentGraphPause } from './admission';
const signal = new AbortController().signal;
const fullAccessSettings: AttachedCodeEnvironmentPolicySettings = {
configSchema: {
permissions: {
fileWrite: { allowed: ['allow', 'ask', 'deny'], default: 'ask' },
commandExecution: { allowed: ['allow', 'ask', 'deny'], default: 'ask' },
},
},
};
describe('full access', () => {
test('allows native writes and commands while preserving mandatory skill review', async () => {
const settings = new Map([['attached-agent', fullAccessSettings]]);
const mode = resolveAttachedCodeApprovalMode('fullAccess', settings);
const hook = createAttachedCodeEnvironmentPolicyHook(new Set(settings.keys()), settings, mode);
for (const toolName of ['create_file', 'edit_file', 'bash_tool', 'execute_code']) {
await expect(
hook(
{
toolName,
executingAgentId: 'attached-agent',
toolInput: { path: 'output.txt' },
} as never,
signal,
),
).resolves.toEqual({ decision: 'allow' });
}
await expect(
hook(
{
toolName: 'create_file',
executingAgentId: 'attached-agent',
toolInput: { path: 'skills/reviewer/SKILL.md' },
} as never,
signal,
),
).resolves.toMatchObject({ decision: 'ask' });
await expect(hook({ toolName: 'bash_tool' } as never, signal)).resolves.toMatchObject({
decision: 'deny',
});
await expect(
hook({ toolName: 'mcp_example', executingAgentId: 'attached-agent' } as never, signal),
).resolves.toEqual({});
});
test.each([false, true])(
'rejects restrictive siblings regardless of traversal order: %s',
(reverse) => {
const entries: Array<[string, AttachedCodeEnvironmentPolicySettings]> = [
['permissive', fullAccessSettings],
[
'restricted',
{ configSchema: { permissions: { fileWrite: { allowed: ['ask'], default: 'ask' } } } },
],
];
expect(() =>
resolveAttachedCodeApprovalMode(
'fullAccess',
new Map(reverse ? entries.reverse() : entries),
),
).toThrow('not permitted');
},
);
test('rechecks changed and newly discovered machine restrictions before execution', async () => {
const settings = new Map([['attached-agent', fullAccessSettings]]);
const attachedIds = new Set(settings.keys());
const hook = createAttachedCodeEnvironmentPolicyHook(
attachedIds,
settings,
resolveAttachedCodeApprovalMode('fullAccess', settings),
);
settings.set('attached-agent', {
...fullAccessSettings,
settings: { permissions: { commandExecution: 'deny' } },
});
await expect(
hook({ toolName: 'bash_tool', executingAgentId: 'attached-agent' } as never, signal),
).resolves.toMatchObject({ decision: 'deny' });
attachedIds.add('lazy-agent');
settings.set('lazy-agent', {});
await expect(
hook({ toolName: 'bash_tool', executingAgentId: 'lazy-agent' } as never, signal),
).resolves.toMatchObject({ decision: 'ask' });
expect(() => resolveAttachedCodeApprovalMode('fullAccess', settings, false)).toThrow(
'not permitted',
);
});
});
test('identifies every built-in tool that can touch a stateful code target', () => {
for (const toolName of [
'read_file',

View file

@ -238,6 +238,8 @@ export function resolveAttachedCodeApprovalMode(
settings: policy.settings,
});
} catch (error) {
/** Unattended execution requires every known target to permit the mode. */
if (requested === 'fullAccess') throw error;
rejection = error as Error;
}
}

View file

@ -5,6 +5,63 @@ import { resolveToolApprovalPolicy } from './policy';
import { buildHITLRunWiring } from './runtime';
describe('buildHITLRunWiring', () => {
test.each([
['ask', 'bash_tool', 'ask'],
['deny', 'bash_tool', 'deny'],
['allow', 'bash_tool', 'allow'],
['allow', 'mcp:github:create_issue', 'ask'],
] as const)(
'full access preserves endpoint %s rules for %s',
async (rule, toolName, expected) => {
const settings = new Map([
[
'attached-agent',
{
configSchema: {
permissions: {
fileWrite: {
allowed: ['ask', 'allow'] as Array<'ask' | 'allow'>,
default: 'ask' as const,
},
commandExecution: {
allowed: ['ask', 'allow'] as Array<'ask' | 'allow'>,
default: 'ask' as const,
},
},
},
},
],
]);
const wiring = buildHITLRunWiring(
{ enabled: true, mode: 'default', [rule]: ['bash_tool'] },
{},
[],
[
{
hook: createAttachedCodeEnvironmentPolicyHook(
new Set(settings.keys()),
settings,
'fullAccess',
),
},
],
);
const result = await executeHooks({
registry: wiring!.hooks,
matchQuery: toolName,
input: {
hook_event_name: 'PreToolUse',
runId: 'full-access-policy',
toolName,
toolInput: {},
toolUseId: 'tool-code',
executingAgentId: 'attached-agent',
},
});
expect(result.decision).toBe(expected);
},
);
test('returns undefined when HITL is disabled (the default)', () => {
expect(buildHITLRunWiring(undefined)).toBeUndefined();
expect(buildHITLRunWiring({})).toBeUndefined();

View file

@ -274,7 +274,7 @@ describe('createEndpointsConfigService', () => {
expect(result?.[EModelEndpoint.agents]?.statefulCodeSessions).toEqual({
allowedEnvironments: ['user'],
approvalsEnabled: true,
approvalModes: ['ask', 'acceptEdits'],
approvalModes: ['ask', 'acceptEdits', 'fullAccess'],
environments: [],
});
});
@ -283,7 +283,7 @@ describe('createEndpointsConfigService', () => {
[{ enabled: true }, ['ask']],
[{ enabled: true, mode: 'default' }, ['ask']],
[{ enabled: true, mode: 'dontAsk' }, ['ask']],
[{ enabled: true, mode: 'bypass' }, ['ask', 'acceptEdits']],
[{ enabled: true, mode: 'bypass' }, ['ask', 'acceptEdits', 'fullAccess']],
])('exposes approval modes allowed by endpoint policy %p', async (toolApproval, expected) => {
const deps = createMockDeps({
loadDefaultEndpointsConfig: jest.fn().mockResolvedValue({

View file

@ -97,7 +97,7 @@ describe('conversation code approval constraints', () => {
).toEqual(['ask']);
});
test.each(['autoApprove', 'bypass', 'fullAccess', '', {}, ['ask'], true, 1])(
test.each(['autoApprove', 'bypass', 'invalidMode', '', {}, ['ask'], true, 1])(
'rejects invalid request state: %j',
(value) => {
expect(() => resolveCodeApprovalMode(value, constraints)).toThrow(CodeApprovalModeError);
@ -107,7 +107,7 @@ describe('conversation code approval constraints', () => {
test('rejects an unvalidated runtime mode before permission lookup', () => {
expect(() =>
resolveCodePermissionDecision({
mode: 'fullAccess' as never,
mode: 'invalidMode' as never,
category: 'fileWrite',
decision: 'ask',
}),
@ -127,6 +127,24 @@ describe('conversation code approval constraints', () => {
}
});
test('full access allows commands and file writes only with both machine grants', () => {
const mode = resolveCodeApprovalMode('fullAccess', constraints);
for (const category of ['fileWrite', 'commandExecution'] as const) {
expect(resolveCodePermissionDecision({ mode, category, decision: 'ask' })).toBe('allow');
expect(() =>
resolveCodeApprovalMode('fullAccess', {
...constraints,
configSchema: {
permissions: {
...constraints.configSchema?.permissions,
[category]: { allowed: ['ask'], default: 'ask' },
},
},
}),
).toThrow(CodeApprovalModeError);
}
});
test('accept edits asks for commands and does not mutate its input', () => {
const before = JSON.stringify(constraints);
const mode = resolveCodeApprovalMode('acceptEdits', constraints);

View file

@ -4,7 +4,7 @@ import type {
CodeEnvironmentUserSettings,
} from '../config';
export const CODE_APPROVAL_MODES = ['ask', 'acceptEdits'] as const;
export const CODE_APPROVAL_MODES = ['ask', 'acceptEdits', 'fullAccess'] as const;
export type CodeApprovalMode = (typeof CODE_APPROVAL_MODES)[number];
type CodePermissions = Required<NonNullable<CodeEnvironmentUserSettings['permissions']>>;
@ -12,6 +12,7 @@ type CodePermissions = Required<NonNullable<CodeEnvironmentUserSettings['permiss
const MODE_PERMISSIONS: Record<CodeApprovalMode, CodePermissions> = {
ask: { fileWrite: 'ask', commandExecution: 'ask' },
acceptEdits: { fileWrite: 'allow', commandExecution: 'ask' },
fullAccess: { fileWrite: 'allow', commandExecution: 'allow' },
};
export type CodeApprovalConstraints = {