diff --git a/.gemini/skills/behavioral-evals/references/fixing.md b/.gemini/skills/behavioral-evals/references/fixing.md index fc78870515..6cbdee36e1 100644 --- a/.gemini/skills/behavioral-evals/references/fixing.md +++ b/.gemini/skills/behavioral-evals/references/fixing.md @@ -33,6 +33,16 @@ evaluation. - **Warning**: Do not lose test fidelity by making prompts too direct/easy. - **Primary Fix Trigger**: Adjust tool descriptions, system prompts (`snippets.ts`), or **modules that contribute to the prompt template**. + - Fixes should generally try to improve the prompt `@packages/core/src/prompts/snippets.ts` first. + - **Instructional Generality**: Changes to the system prompt should aim to be as general as possible while still accomplishing the goal. Specificity should be added only as needed. + - **Principle**: Instead of creating "forbidden lists" for specific syntax (e.g., "Don't use `Object.create()`"), formulate a broader engineering principle that covers the underlying issue (e.g., "Prioritize explicit composition over hidden prototype manipulation"). This improves steerability across a wider range of similar scenarios. + - *Low Specificity*: "Follow ecosystem best practices" + - *Medium Specificity*: "Utilize OOP and functional best practices, as applicable" + - *High Specificity*: Provide ecosystem-specific hints as examples of a broader principle rather than direct instructions. e.g., "NEVER use hacks like bypassing the type system or employing 'hidden' logic (e.g.: reflection, prototype manipulation). Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity." + - **Prompt Simplification**: Once the test is passing, use `ask_user` to determine if prompt simplification is desired. + - **Criteria**: Simplification should be attempted only if there are related clauses that can be de-duplicated or reparented under a single heading. + - **Verification**: As part of simplification, you MUST identify and run any behavioral eval tests that might be affected by the changes to ensure no regressions are introduced. + - Test fixes should not "cheat" by changing a test's `GEMINI.md` file or by updating the test's prompt to instruct it to not repro the bug. - **Warning**: Prompts have multiple configurations; ensure your fix targets the correct config for the model in question. 4. **Architecture Options**: If prompt or instruction tuning triggers no diff --git a/.github/workflows/eval-pr.yml b/.github/workflows/eval-pr.yml index e0f839e667..9da0fc8511 100644 --- a/.github/workflows/eval-pr.yml +++ b/.github/workflows/eval-pr.yml @@ -46,12 +46,6 @@ jobs: node-version-file: '.nvmrc' cache: 'npm' - - name: 'Install dependencies' - run: 'npm ci' - - - name: 'Build project' - run: 'npm run build' - - name: 'Detect Steering Changes' id: 'detect' run: | @@ -60,6 +54,14 @@ jobs: echo "SHOULD_RUN=$SHOULD_RUN" >> "$GITHUB_OUTPUT" echo "STEERING_DETECTED=$STEERING_DETECTED" >> "$GITHUB_OUTPUT" + - name: 'Install dependencies' + if: "steps.detect.outputs.SHOULD_RUN == 'true'" + run: 'npm ci' + + - name: 'Build project' + if: "steps.detect.outputs.SHOULD_RUN == 'true'" + run: 'npm run build' + - name: 'Analyze PR Content (Guidance)' if: "steps.detect.outputs.STEERING_DETECTED == 'true'" id: 'analysis' @@ -94,7 +96,7 @@ jobs: fi - name: 'Post or Update PR Comment' - if: "always() && steps.detect.outputs.STEERING_DETECTED == 'true'" + if: "always() && (steps.detect.outputs.STEERING_DETECTED == 'true' || env.REPORT_FILE != '')" env: GH_TOKEN: '${{ secrets.GITHUB_TOKEN }}' run: | @@ -104,17 +106,20 @@ jobs: cat eval_regression_report.md echo "" fi - echo "### 🧠 Model Steering Guidance" - echo "" - echo "This PR modifies files that affect the model's behavior (prompts, tools, or instructions)." - echo "" - if [[ "${{ steps.analysis.outputs.MISSING_EVALS }}" == "true" ]]; then - echo "- ⚠️ **Consider adding Evals:** No behavioral evaluations (\`evals/*.eval.ts\`) were added or updated in this PR. Consider [adding a test case](https://github.com/google-gemini/gemini-cli/blob/main/evals/README.md#creating-an-evaluation) to verify the new behavior and prevent regressions." - fi + if [[ "${{ steps.detect.outputs.STEERING_DETECTED }}" == "true" ]]; then + echo "### 🧠 Model Steering Guidance" + echo "" + echo "This PR modifies files that affect the model's behavior (prompts, tools, or instructions)." + echo "" - if [[ "${{ steps.analysis.outputs.IS_MAINTAINER }}" == "true" ]]; then - echo "- 🚀 **Maintainer Reminder:** Please ensure that these changes do not regress results on benchmark evals before merging." + if [[ "${{ steps.analysis.outputs.MISSING_EVALS }}" == "true" ]]; then + echo "- ⚠️ **Consider adding Evals:** No behavioral evaluations (\`evals/*.eval.ts\`) were added or updated in this PR. Consider [adding a test case](https://github.com/google-gemini/gemini-cli/blob/main/evals/README.md#creating-an-evaluation) to verify the new behavior and prevent regressions." + fi + + if [[ "${{ steps.analysis.outputs.IS_MAINTAINER }}" == "true" ]]; then + echo "- 🚀 **Maintainer Reminder:** Please ensure that these changes do not regress results on benchmark evals before merging." + fi fi echo "" diff --git a/docs/cli/sandbox.md b/docs/cli/sandbox.md index e27587abf0..f81b561e0a 100644 --- a/docs/cli/sandbox.md +++ b/docs/cli/sandbox.md @@ -136,6 +136,58 @@ gemini -p "build the snap" absolute path — the path must be writable inside the container. - Used with tools like Snapcraft or Rockcraft that require a full system. +## Tool sandboxing + +Tool-level sandboxing provides granular isolation for individual tool executions +(like `shell_exec` and `write_file`) instead of sandboxing the entire Gemini CLI +process. + +This approach offers better integration with your local environment for non-tool +tasks (like UI rendering and configuration loading) while still providing +security for tool-driven operations. + +### How to turn off tool sandboxing + +If you experience issues with tool sandboxing or prefer full-process isolation, +you can disable it by setting `security.toolSandboxing` to `false` in your +`settings.json` file. + +```json +{ + "security": { + "toolSandboxing": false + } +} +``` + + +> [!NOTE] +> Changing the `security.toolSandboxing` setting requires a restart of Gemini +> CLI to take effect. + +## Sandbox expansion + +Sandbox expansion is a dynamic permission system that lets Gemini CLI request +additional permissions for a command when needed. + +When a sandboxed command fails due to permission restrictions (like restricted +file paths or network access), or when a command is proactively identified as +requiring extra permissions (like `npm install`), Gemini CLI will present you +with a "Sandbox Expansion Request." + +### How sandbox expansion works + +1. **Detection**: Gemini CLI detects a sandbox denial or proactively identifies + a command that requires extra permissions. +2. **Request**: A modal dialog is shown, explaining which additional + permissions (e.g., specific directories or network access) are required. +3. **Approval**: If you approve the expansion, the command is executed with the + extended permissions for that specific run. + +This mechanism ensures you don't have to manually re-run commands with more +permissive sandbox settings, while still maintaining control over what the AI +can access. + ## Quickstart ```bash diff --git a/docs/cli/settings.md b/docs/cli/settings.md index ec121bb833..4a6b9a77b7 100644 --- a/docs/cli/settings.md +++ b/docs/cli/settings.md @@ -60,7 +60,7 @@ they appear in the UI. | Hide Tips | `ui.hideTips` | Hide helpful tips in the UI | `false` | | Escape Pasted @ Symbols | `ui.escapePastedAtSymbols` | When enabled, @ symbols in pasted text are escaped to prevent unintended @path expansion. | `false` | | Show Shortcuts Hint | `ui.showShortcutsHint` | Show the "? for shortcuts" hint above the input. | `true` | -| Compact Tool Output | `ui.compactToolOutput` | Display tool outputs (like directory listings and file reads) in a compact, structured format. | `false` | +| Compact Tool Output | `ui.compactToolOutput` | Display tool outputs (like directory listings and file reads) in a compact, structured format. | `true` | | Hide Banner | `ui.hideBanner` | Hide the application banner | `false` | | Hide Context Summary | `ui.hideContextSummary` | Hide the context summary (GEMINI.md, MCP servers) above the input. | `false` | | Hide CWD | `ui.footer.hideCWD` | Hide the current working directory in the footer. | `false` | @@ -131,7 +131,7 @@ they appear in the UI. | Sandbox Allowed Paths | `tools.sandboxAllowedPaths` | List of additional paths that the sandbox is allowed to access. | `[]` | | Sandbox Network Access | `tools.sandboxNetworkAccess` | Whether the sandbox is allowed to access the network. | `false` | | Enable Interactive Shell | `tools.shell.enableInteractiveShell` | Use node-pty for an interactive shell experience. Fallback to child_process still applies. | `true` | -| Show Color | `tools.shell.showColor` | Show color in shell output. | `false` | +| Show Color | `tools.shell.showColor` | Show color in shell output. | `true` | | Use Ripgrep | `tools.useRipgrep` | Use ripgrep for file content search instead of the fallback implementation. Provides faster search performance. | `true` | | Tool Output Truncation Threshold | `tools.truncateToolOutputThreshold` | Maximum characters to show when truncating large tool outputs. Set to 0 or negative to disable truncation. | `40000` | | Disable LLM Correction | `tools.disableLLMCorrection` | Disable LLM-based error correction for edit tools. When enabled, tools will fail immediately if exact string matches are not found, instead of attempting to self-correct. | `true` | @@ -140,7 +140,7 @@ they appear in the UI. | UI Label | Setting | Description | Default | | ------------------------------------- | ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------- | -| Tool Sandboxing | `security.toolSandboxing` | Experimental tool-level sandboxing (implementation in progress). | `false` | +| Tool Sandboxing | `security.toolSandboxing` | Tool-level sandboxing. Isolates individual tools instead of the entire CLI process. | `false` | | Disable YOLO Mode | `security.disableYoloMode` | Disable YOLO mode, even if enabled by a flag. | `false` | | Disable Always Allow | `security.disableAlwaysAllow` | Disable "Always allow" options in tool confirmation dialogs. | `false` | | Allow Permanent Tool Approval | `security.enablePermanentToolApproval` | Enable the "Allow for all future sessions" option in tool confirmation dialogs. | `false` | diff --git a/docs/reference/configuration.md b/docs/reference/configuration.md index 2e8e3f374c..5c9a3e7044 100644 --- a/docs/reference/configuration.md +++ b/docs/reference/configuration.md @@ -267,7 +267,7 @@ their corresponding top-level category object in your `settings.json` file. - **`ui.compactToolOutput`** (boolean): - **Description:** Display tool outputs (like directory listings and file reads) in a compact, structured format. - - **Default:** `false` + - **Default:** `true` - **`ui.hideBanner`** (boolean): - **Description:** Hide the application banner @@ -1404,7 +1404,7 @@ their corresponding top-level category object in your `settings.json` file. - **`tools.shell.showColor`** (boolean): - **Description:** Show color in shell output. - - **Default:** `false` + - **Default:** `true` - **`tools.shell.inactivityTimeout`** (number): - **Description:** The maximum time in seconds allowed without output from the @@ -1492,9 +1492,10 @@ their corresponding top-level category object in your `settings.json` file. #### `security` - **`security.toolSandboxing`** (boolean): - - **Description:** Experimental tool-level sandboxing (implementation in - progress). + - **Description:** Tool-level sandboxing. Isolates individual tools instead of + the entire CLI process. - **Default:** `false` + - **Requires restart:** Yes - **`security.disableYoloMode`** (boolean): - **Description:** Disable YOLO mode, even if enabled by a flag. diff --git a/evals/unsafe-cloning.eval.ts b/evals/unsafe-cloning.eval.ts new file mode 100644 index 0000000000..7a37a77c1b --- /dev/null +++ b/evals/unsafe-cloning.eval.ts @@ -0,0 +1,64 @@ +/** + * @license + * Copyright 2026 Google LLC + * SPDX-License-Identifier: Apache-2.0 + */ + +import { evalTest, TestRig } from './test-helper.js'; + +evalTest('USUALLY_PASSES', { + name: 'Reproduction: Agent uses Object.create() for cloning/delegation', + prompt: + 'Create a utility function `createScopedConfig(config: Config, additionalDirectories: string[]): Config` in `packages/core/src/config/scoped-config.ts` that returns a new Config instance. This instance should override `getWorkspaceContext()` to include the additional directories, but delegate all other method calls (like `isPathAllowed` or `validatePathAccess`) to the original config. Note that `Config` is a complex class with private state and cannot be easily shallow-copied or reconstructed.', + files: { + 'packages/core/src/config/config.ts': ` +export class Config { + private _internalState = 'secret'; + constructor(private workspaceContext: any) {} + getWorkspaceContext() { return this.workspaceContext; } + isPathAllowed(path: string) { + return this.getWorkspaceContext().isPathWithinWorkspace(path); + } + validatePathAccess(path: string) { + if (!this.isPathAllowed(path)) return 'Denied'; + return null; + } +}`, + 'packages/core/src/utils/workspaceContext.ts': ` +export class WorkspaceContext { + constructor(private root: string, private additional: string[] = []) {} + getDirectories() { return [this.root, ...this.additional]; } + isPathWithinWorkspace(path: string) { + return this.getDirectories().some(d => path.startsWith(d)); + } +}`, + 'package.json': JSON.stringify({ + name: 'test-project', + version: '1.0.0', + type: 'module', + }), + }, + assert: async (rig: TestRig) => { + const filePath = 'packages/core/src/config/scoped-config.ts'; + const content = rig.readFile(filePath); + + if (!content) { + throw new Error(`File ${filePath} was not created.`); + } + + // Strip comments to avoid false positives. + const codeWithoutComments = content.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, ''); + + // Ensure that the agent did not use Object.create() in the implementation. + // We check for the call pattern specifically using a regex to avoid false positives in comments. + const hasObjectCreate = /\bObject\.create\s*\(/.test(codeWithoutComments); + if (hasObjectCreate) { + throw new Error( + 'Evaluation Failed: Agent used Object.create() for cloning. ' + + 'This behavior is forbidden by the project lint rules (no-restricted-syntax). ' + + 'Implementation found:\n\n' + + content, + ); + } + }, +}); diff --git a/evals/update_topic.eval.ts b/evals/update_topic.eval.ts index 1836e7f61b..8a6f3f75ac 100644 --- a/evals/update_topic.eval.ts +++ b/evals/update_topic.eval.ts @@ -5,6 +5,8 @@ */ import { describe, expect } from 'vitest'; +import fs from 'node:fs'; +import path from 'node:path'; import { evalTest } from './test-helper.js'; describe('update_topic_behavior', () => { @@ -113,4 +115,147 @@ describe('update_topic_behavior', () => { } }, }); + + evalTest('USUALLY_PASSES', { + name: 'update_topic should NOT be used for informational coding tasks (Obvious)', + approvalMode: 'default', + prompt: + 'Explain the difference between Map and Object in JavaScript and provide a performance-focused code snippet for each.', + files: { + '.gemini/settings.json': JSON.stringify({ + experimental: { + topicUpdateNarration: true, + }, + }), + }, + assert: async (rig) => { + const toolLogs = rig.readToolLogs(); + const topicCalls = toolLogs.filter( + (l) => l.toolRequest.name === UPDATE_TOPIC_TOOL_NAME, + ); + + expect( + topicCalls.length, + `Expected 0 update_topic calls for an informational task, but found ${topicCalls.length}`, + ).toBe(0); + }, + }); + + evalTest('USUALLY_PASSES', { + name: 'update_topic should NOT be used for surgical symbol searches (Grey Area)', + approvalMode: 'default', + prompt: + "Find the file where the 'UPDATE_TOPIC_TOOL_NAME' constant is defined.", + files: { + 'packages/core/src/tools/tool-names.ts': + "export const UPDATE_TOPIC_TOOL_NAME = 'update_topic';", + '.gemini/settings.json': JSON.stringify({ + experimental: { + topicUpdateNarration: true, + }, + }), + }, + assert: async (rig) => { + const toolLogs = rig.readToolLogs(); + const topicCalls = toolLogs.filter( + (l) => l.toolRequest.name === UPDATE_TOPIC_TOOL_NAME, + ); + + expect( + topicCalls.length, + `Expected 0 update_topic calls for a surgical symbol search, but found ${topicCalls.length}`, + ).toBe(0); + }, + }); + + evalTest('USUALLY_PASSES', { + name: 'update_topic should be used for medium complexity multi-step tasks', + prompt: + 'Refactor the `users-api` project. Move the routing logic from src/app.ts into a new file src/routes.ts, and update app.ts to use the new routes file.', + files: { + 'package.json': JSON.stringify( + { + name: 'users-api', + version: '1.0.0', + }, + null, + 2, + ), + 'src/app.ts': ` +import express from 'express'; +const app = express(); + +app.get('/users', (req, res) => { + res.json([{id: 1, name: 'Alice'}]); +}); + +app.post('/users', (req, res) => { + res.status(201).send(); +}); + +export default app; + `, + '.gemini/settings.json': JSON.stringify({ + experimental: { + topicUpdateNarration: true, + }, + }), + }, + assert: async (rig) => { + const toolLogs = rig.readToolLogs(); + const topicCalls = toolLogs.filter( + (l) => l.toolRequest.name === UPDATE_TOPIC_TOOL_NAME, + ); + + // This is a multi-step task (read, create new file, edit old file). + // It should clear the bar and use update_topic at least at the start and end. + expect(topicCalls.length).toBeGreaterThanOrEqual(2); + + // Verify it actually did the refactoring to ensure it didn't just fail immediately + expect(fs.existsSync(path.join(rig.testDir, 'src/routes.ts'))).toBe(true); + }, + }); + + /** + * Regression test for a bug where update_topic was called multiple times in a + * row. We have seen cases of this occurring in earlier versions of the update_topic + * system instruction, prior to https://github.com/google-gemini/gemini-cli/pull/24640. + * This test demonstrated that there are cases where it can still occur and validates + * the prompt change that improves the behavior. + */ + evalTest('USUALLY_PASSES', { + name: 'update_topic should not be called twice in a row', + prompt: ` + We need to build a C compiler. + + Before you write any code, you must formally declare your strategy. + First, declare that you will build a Lexer. + Then, immediately realize that is wrong and declare that you will actually build a Parser instead. + + Finally, create 'parser.c'. + `, + files: { + 'package.json': JSON.stringify({ name: 'test-project' }), + '.gemini/settings.json': JSON.stringify({ + experimental: { + topicUpdateNarration: true, + }, + }), + }, + assert: async (rig) => { + const toolLogs = rig.readToolLogs(); + + // Check for back-to-back update_topic calls + for (let i = 1; i < toolLogs.length; i++) { + if ( + toolLogs[i - 1].toolRequest.name === UPDATE_TOPIC_TOOL_NAME && + toolLogs[i].toolRequest.name === UPDATE_TOPIC_TOOL_NAME + ) { + throw new Error( + `Detected back-to-back ${UPDATE_TOPIC_TOOL_NAME} calls at index ${i - 1} and ${i}`, + ); + } + } + }, + }); }); diff --git a/integration-tests/browser-agent.persistent-session.responses b/integration-tests/browser-agent.persistent-session.responses new file mode 100644 index 0000000000..ee224858f1 --- /dev/null +++ b/integration-tests/browser-agent.persistent-session.responses @@ -0,0 +1,8 @@ +{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"text":"I'll browse to example.com twice to verify the content. Let me first check the page title, then check the links on the page."},{"functionCall":{"name":"browser_agent","args":{"task":"Navigate to https://example.com and tell me the page title using the accessibility tree"}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":100,"candidatesTokenCount":50,"totalTokenCount":150}}]} +{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"navigate_page","args":{"url":"https://example.com"}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":100,"candidatesTokenCount":30,"totalTokenCount":130}}]} +{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"take_snapshot","args":{}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":150,"candidatesTokenCount":20,"totalTokenCount":170}}]} +{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"complete_task","args":{"result":{"success":true,"summary":"Page title is 'Example Domain'."}}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":200,"candidatesTokenCount":40,"totalTokenCount":240}}]} +{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"text":"The page title is 'Example Domain'. Now let me check the links on the page."},{"functionCall":{"name":"browser_agent","args":{"task":"Take a snapshot of the accessibility tree on the currently open page and tell me about any links"}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":200,"candidatesTokenCount":50,"totalTokenCount":250}}]} +{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"take_snapshot","args":{}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":150,"candidatesTokenCount":20,"totalTokenCount":170}}]} +{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"functionCall":{"name":"complete_task","args":{"result":{"success":true,"summary":"Found a link 'More information...' pointing to iana.org."}}}}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":200,"candidatesTokenCount":40,"totalTokenCount":240}}]} +{"method":"generateContentStream","response":[{"candidates":[{"content":{"parts":[{"text":"I browsed example.com twice using persistent browser sessions:\n\n1. **First visit**: Page title is 'Example Domain'\n2. **Second visit**: Found a link 'More information...' pointing to iana.org\n\nThe browser stayed open between both visits, confirming persistent session management works correctly."}],"role":"model"},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":300,"candidatesTokenCount":60,"totalTokenCount":360}}]} diff --git a/integration-tests/browser-agent.test.ts b/integration-tests/browser-agent.test.ts index 6545040e98..09e20bcb26 100644 --- a/integration-tests/browser-agent.test.ts +++ b/integration-tests/browser-agent.test.ts @@ -229,6 +229,51 @@ describe.skipIf(!chromeAvailable)('browser-agent', () => { assertModelHasOutput(result); }); + it('should keep browser open across multiple browser_agent invocations', async () => { + rig.setup('browser-persistent-session', { + fakeResponsesPath: join( + __dirname, + 'browser-agent.persistent-session.responses', + ), + settings: { + agents: { + overrides: { + browser_agent: { + enabled: true, + }, + }, + browser: { + headless: true, + sessionMode: 'isolated', + }, + }, + }, + }); + + const result = await rig.run({ + args: 'Browse to example.com twice: first get the page title, then check for links.', + }); + + const toolLogs = rig.readToolLogs(); + const browserCalls = toolLogs.filter( + (t) => t.toolRequest.name === 'browser_agent', + ); + + // Both browser_agent invocations must succeed — if the browser was + // incorrectly closed after the first call (regression #24210), + // the second call would fail. + expect( + browserCalls.length, + 'Expected browser_agent to be called twice', + ).toBe(2); + expect( + browserCalls.every((c) => c.toolRequest.success), + 'Both browser_agent calls should succeed', + ).toBe(true); + + assertModelHasOutput(result); + }); + it('should handle tool confirmation for write_file without crashing', async () => { rig.setup('tool-confirmation', { fakeResponsesPath: join( diff --git a/integration-tests/utf-bom-encoding.test.ts b/integration-tests/utf-bom-encoding.test.ts index 5ecc1e53c7..5961a1b224 100644 --- a/integration-tests/utf-bom-encoding.test.ts +++ b/integration-tests/utf-bom-encoding.test.ts @@ -5,8 +5,8 @@ */ import { describe, it, expect, beforeEach, afterEach } from 'vitest'; -import { writeFileSync, readFileSync } from 'node:fs'; -import { join, resolve } from 'node:path'; +import { writeFileSync } from 'node:fs'; +import { join } from 'node:path'; import { TestRig } from './test-helper.js'; // BOM encoders @@ -116,21 +116,4 @@ describe('BOM end-to-end integraion', () => { 'BOM_OK UTF-32BE', ); }); - - it('Can describe a PNG file', async () => { - const imagePath = resolve( - process.cwd(), - 'docs/assets/gemini-screenshot.png', - ); - const imageContent = readFileSync(imagePath); - const filename = 'gemini-screenshot.png'; - writeFileSync(join(rig.testDir!, filename), imageContent); - const prompt = `What is shown in the image ${filename}?`; - const output = await rig.run({ args: prompt }); - await rig.waitForToolCall('read_file'); - const lower = output.toLowerCase(); - // The response is non-deterministic, so we just check for some - // keywords that are very likely to be in the response. - expect(lower.includes('gemini')).toBeTruthy(); - }); }); diff --git a/packages/a2a-server/src/http/server.ts b/packages/a2a-server/src/http/server.ts index 1bfb29c081..c22be49331 100644 --- a/packages/a2a-server/src/http/server.ts +++ b/packages/a2a-server/src/http/server.ts @@ -1,4 +1,4 @@ -#!/usr/bin/env -S node --no-warnings=DEP0040 +#!/usr/bin/env node /** * @license diff --git a/packages/cli/index.ts b/packages/cli/index.ts index 5444fe1b74..d94a2dd191 100644 --- a/packages/cli/index.ts +++ b/packages/cli/index.ts @@ -1,4 +1,4 @@ -#!/usr/bin/env -S node --no-warnings=DEP0040 +#!/usr/bin/env node /** * @license diff --git a/packages/cli/src/acp/commandHandler.test.ts b/packages/cli/src/acp/commandHandler.test.ts index 8e04f014f3..23bf907ec3 100644 --- a/packages/cli/src/acp/commandHandler.test.ts +++ b/packages/cli/src/acp/commandHandler.test.ts @@ -26,5 +26,8 @@ describe('CommandHandler', () => { const init = parse('/init'); expect(init.commandToExecute?.name).toBe('init'); + + const about = parse('/about'); + expect(about.commandToExecute?.name).toBe('about'); }); }); diff --git a/packages/cli/src/acp/commandHandler.ts b/packages/cli/src/acp/commandHandler.ts index 836cdf7736..4ed846188e 100644 --- a/packages/cli/src/acp/commandHandler.ts +++ b/packages/cli/src/acp/commandHandler.ts @@ -10,6 +10,7 @@ import { MemoryCommand } from './commands/memory.js'; import { ExtensionsCommand } from './commands/extensions.js'; import { InitCommand } from './commands/init.js'; import { RestoreCommand } from './commands/restore.js'; +import { AboutCommand } from './commands/about.js'; export class CommandHandler { private registry: CommandRegistry; @@ -24,6 +25,7 @@ export class CommandHandler { registry.register(new ExtensionsCommand()); registry.register(new InitCommand()); registry.register(new RestoreCommand()); + registry.register(new AboutCommand()); return registry; } diff --git a/packages/cli/src/acp/commands/about.ts b/packages/cli/src/acp/commands/about.ts new file mode 100644 index 0000000000..06349e88d7 --- /dev/null +++ b/packages/cli/src/acp/commands/about.ts @@ -0,0 +1,74 @@ +/** + * @license + * Copyright 2026 Google LLC + * SPDX-License-Identifier: Apache-2.0 + */ + +import { + IdeClient, + UserAccountManager, + getVersion, +} from '@google/gemini-cli-core'; +import type { + Command, + CommandContext, + CommandExecutionResponse, +} from './types.js'; +import process from 'node:process'; + +export class AboutCommand implements Command { + readonly name = 'about'; + readonly description = 'Show version and environment info'; + + async execute( + context: CommandContext, + _args: string[] = [], + ): Promise { + const osVersion = process.platform; + let sandboxEnv = 'no sandbox'; + if (process.env['SANDBOX'] && process.env['SANDBOX'] !== 'sandbox-exec') { + sandboxEnv = process.env['SANDBOX']; + } else if (process.env['SANDBOX'] === 'sandbox-exec') { + sandboxEnv = `sandbox-exec (${ + process.env['SEATBELT_PROFILE'] || 'unknown' + })`; + } + const modelVersion = context.agentContext.config.getModel() || 'Unknown'; + const cliVersion = await getVersion(); + const selectedAuthType = + context.settings.merged?.security?.auth?.selectedType ?? ''; + const gcpProject = process.env['GOOGLE_CLOUD_PROJECT'] || ''; + const ideClient = await getIdeClientName(context); + + const userAccountManager = new UserAccountManager(); + const cachedAccount = userAccountManager.getCachedGoogleAccount(); + const userEmail = cachedAccount ?? 'Unknown'; + + const tier = context.agentContext.config.getUserTierName() || 'Unknown'; + + const info = [ + `- Version: ${cliVersion}`, + `- OS: ${osVersion}`, + `- Sandbox: ${sandboxEnv}`, + `- Model: ${modelVersion}`, + `- Auth Type: ${selectedAuthType}`, + `- GCP Project: ${gcpProject}`, + `- IDE Client: ${ideClient}`, + `- User Email: ${userEmail}`, + `- Tier: ${tier}`, + ].join('\n'); + + return { + name: this.name, + data: `Gemini CLI Info:\n${info}`, + }; + } +} + +async function getIdeClientName(context: CommandContext) { + if (!context.agentContext.config.getIdeMode()) { + return ''; + } + const ideClient = await IdeClient.getInstance(); + return ideClient?.getDetectedIdeDisplayName() ?? ''; +} diff --git a/packages/cli/src/commands/skills/list.test.ts b/packages/cli/src/commands/skills/list.test.ts index 391749242b..37f6b26613 100644 --- a/packages/cli/src/commands/skills/list.test.ts +++ b/packages/cli/src/commands/skills/list.test.ts @@ -4,8 +4,16 @@ * SPDX-License-Identifier: Apache-2.0 */ -import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest'; -import { coreEvents, type Config } from '@google/gemini-cli-core'; +import { + vi, + describe, + it, + expect, + beforeEach, + afterEach, + type MockInstance, +} from 'vitest'; +import { type Config } from '@google/gemini-cli-core'; import { handleList, listCommand } from './list.js'; import { loadSettings, type LoadedSettings } from '../../config/settings.js'; import { loadCliConfig } from '../../config/config.js'; @@ -32,12 +40,16 @@ vi.mock('../utils.js', () => ({ describe('skills list command', () => { const mockLoadSettings = vi.mocked(loadSettings); const mockLoadCliConfig = vi.mocked(loadCliConfig); + let stdoutWriteSpy: MockInstance; beforeEach(async () => { vi.clearAllMocks(); mockLoadSettings.mockReturnValue({ merged: {}, } as unknown as LoadedSettings); + stdoutWriteSpy = vi + .spyOn(process.stdout, 'write') + .mockImplementation(() => true); }); afterEach(() => { @@ -56,10 +68,7 @@ describe('skills list command', () => { await handleList({}); - expect(coreEvents.emitConsoleLog).toHaveBeenCalledWith( - 'log', - 'No skills discovered.', - ); + expect(stdoutWriteSpy).toHaveBeenCalledWith('No skills discovered.\n'); }); it('should list all discovered skills', async () => { @@ -87,24 +96,19 @@ describe('skills list command', () => { await handleList({}); - expect(coreEvents.emitConsoleLog).toHaveBeenCalledWith( - 'log', - chalk.bold('Discovered Agent Skills:'), + expect(stdoutWriteSpy).toHaveBeenCalledWith( + chalk.bold('Discovered Agent Skills:') + '\n\n', ); - expect(coreEvents.emitConsoleLog).toHaveBeenCalledWith( - 'log', + expect(stdoutWriteSpy).toHaveBeenCalledWith( expect.stringContaining('skill1'), ); - expect(coreEvents.emitConsoleLog).toHaveBeenCalledWith( - 'log', + expect(stdoutWriteSpy).toHaveBeenCalledWith( expect.stringContaining(chalk.green('[Enabled]')), ); - expect(coreEvents.emitConsoleLog).toHaveBeenCalledWith( - 'log', + expect(stdoutWriteSpy).toHaveBeenCalledWith( expect.stringContaining('skill2'), ); - expect(coreEvents.emitConsoleLog).toHaveBeenCalledWith( - 'log', + expect(stdoutWriteSpy).toHaveBeenCalledWith( expect.stringContaining(chalk.red('[Disabled]')), ); }); @@ -135,12 +139,10 @@ describe('skills list command', () => { // Default await handleList({ all: false }); - expect(coreEvents.emitConsoleLog).toHaveBeenCalledWith( - 'log', + expect(stdoutWriteSpy).toHaveBeenCalledWith( expect.stringContaining('regular'), ); - expect(coreEvents.emitConsoleLog).not.toHaveBeenCalledWith( - 'log', + expect(stdoutWriteSpy).not.toHaveBeenCalledWith( expect.stringContaining('builtin'), ); @@ -148,16 +150,13 @@ describe('skills list command', () => { // With all: true await handleList({ all: true }); - expect(coreEvents.emitConsoleLog).toHaveBeenCalledWith( - 'log', + expect(stdoutWriteSpy).toHaveBeenCalledWith( expect.stringContaining('regular'), ); - expect(coreEvents.emitConsoleLog).toHaveBeenCalledWith( - 'log', + expect(stdoutWriteSpy).toHaveBeenCalledWith( expect.stringContaining('builtin'), ); - expect(coreEvents.emitConsoleLog).toHaveBeenCalledWith( - 'log', + expect(stdoutWriteSpy).toHaveBeenCalledWith( expect.stringContaining(chalk.gray(' [Built-in]')), ); }); diff --git a/packages/cli/src/commands/skills/list.ts b/packages/cli/src/commands/skills/list.ts index 49fc3a54f1..bc05c6c2af 100644 --- a/packages/cli/src/commands/skills/list.ts +++ b/packages/cli/src/commands/skills/list.ts @@ -5,7 +5,6 @@ */ import type { CommandModule } from 'yargs'; -import { debugLogger } from '@google/gemini-cli-core'; import { loadSettings } from '../../config/settings.js'; import { loadCliConfig, type CliArgs } from '../../config/config.js'; import { exitCli } from '../utils.js'; @@ -42,12 +41,11 @@ export async function handleList(args: { all?: boolean }) { }); if (skills.length === 0) { - debugLogger.log('No skills discovered.'); + process.stdout.write('No skills discovered.\n'); return; } - debugLogger.log(chalk.bold('Discovered Agent Skills:')); - debugLogger.log(''); + process.stdout.write(chalk.bold('Discovered Agent Skills:') + '\n\n'); for (const skill of skills) { const status = skill.disabled @@ -56,10 +54,11 @@ export async function handleList(args: { all?: boolean }) { const builtinSuffix = skill.isBuiltin ? chalk.gray(' [Built-in]') : ''; - debugLogger.log(`${chalk.bold(skill.name)} ${status}${builtinSuffix}`); - debugLogger.log(` Description: ${skill.description}`); - debugLogger.log(` Location: ${skill.location}`); - debugLogger.log(''); + process.stdout.write( + `${chalk.bold(skill.name)} ${status}${builtinSuffix}\n`, + ); + process.stdout.write(` Description: ${skill.description}\n`); + process.stdout.write(` Location: ${skill.location}\n\n`); } } diff --git a/packages/cli/src/config/config.ts b/packages/cli/src/config/config.ts index c1ac3e57dd..4e7e1db6f2 100755 --- a/packages/cli/src/config/config.ts +++ b/packages/cli/src/config/config.ts @@ -938,6 +938,8 @@ export async function loadCliConfig( : undefined, blockedEnvironmentVariables: settings.security?.environmentVariableRedaction?.blocked, + allowedEnvironmentVariables: + settings.security?.environmentVariableRedaction?.allowed, enableEnvironmentVariableRedaction: settings.security?.environmentVariableRedaction?.enabled, userMemory: memoryContent, diff --git a/packages/cli/src/config/settingsSchema.ts b/packages/cli/src/config/settingsSchema.ts index 01e248e797..9343be6b02 100644 --- a/packages/cli/src/config/settingsSchema.ts +++ b/packages/cli/src/config/settingsSchema.ts @@ -576,7 +576,7 @@ const SETTINGS_SCHEMA = { label: 'Compact Tool Output', category: 'UI', requiresRestart: false, - default: false, + default: true, description: 'Display tool outputs (like directory listings and file reads) in a compact, structured format.', showInDialog: true, @@ -1527,7 +1527,7 @@ const SETTINGS_SCHEMA = { label: 'Show Color', category: 'Tools', requiresRestart: false, - default: false, + default: true, description: 'Show color in shell output.', showInDialog: true, }, @@ -1711,10 +1711,10 @@ const SETTINGS_SCHEMA = { type: 'boolean', label: 'Tool Sandboxing', category: 'Security', - requiresRestart: false, + requiresRestart: true, default: false, description: - 'Experimental tool-level sandboxing (implementation in progress).', + 'Tool-level sandboxing. Isolates individual tools instead of the entire CLI process.', showInDialog: true, }, disableYoloMode: { diff --git a/packages/cli/src/test-utils/render.tsx b/packages/cli/src/test-utils/render.tsx index c9982103d3..bf8ca468eb 100644 --- a/packages/cli/src/test-utils/render.tsx +++ b/packages/cli/src/test-utils/render.tsx @@ -504,6 +504,8 @@ const baseMockUiState = { history: [], renderMarkdown: true, streamingState: StreamingState.Idle, + isConfigInitialized: true, + isAuthenticating: false, terminalWidth: 100, terminalHeight: 40, currentModel: 'gemini-pro', @@ -598,6 +600,9 @@ const mockUIActions: UIActions = { clearAccountSuspension: vi.fn(), }; +import { type TextBuffer } from '../ui/components/shared/text-buffer.js'; +import { InputContext, type InputState } from '../ui/contexts/InputContext.js'; + let capturedOverflowState: OverflowState | undefined; let capturedOverflowActions: OverflowActions | undefined; const ContextCapture: React.FC<{ children: React.ReactNode }> = ({ @@ -614,6 +619,7 @@ export const renderWithProviders = async ( shellFocus = true, settings = mockSettings, uiState: providedUiState, + inputState: providedInputState, width, mouseEventsEnabled = false, config, @@ -625,6 +631,7 @@ export const renderWithProviders = async ( shellFocus?: boolean; settings?: LoadedSettings; uiState?: Partial; + inputState?: Partial; width?: number; mouseEventsEnabled?: boolean; config?: Config; @@ -659,6 +666,18 @@ export const renderWithProviders = async ( }, ) as UIState; + const inputState = { + buffer: { text: '' } as unknown as TextBuffer, + userMessages: [], + shellModeActive: false, + showEscapePrompt: false, + copyModeEnabled: false, + inputWidth: 80, + suggestionsWidth: 40, + ...(providedUiState as unknown as Partial), + ...providedInputState, + }; + if (persistentState?.get) { persistentStateMock.get.mockImplementation(persistentState.get); } @@ -708,63 +727,65 @@ export const renderWithProviders = async ( - - - - - - - - - + + + + + + + + - - - - - - - {comp} - - - - - - - - - - - - - - - + + + + + + + + {comp} + + + + + + + + + + + + + + + + diff --git a/packages/cli/src/ui/AppContainer.test.tsx b/packages/cli/src/ui/AppContainer.test.tsx index 21bd931d8f..d78b56e11d 100644 --- a/packages/cli/src/ui/AppContainer.test.tsx +++ b/packages/cli/src/ui/AppContainer.test.tsx @@ -122,13 +122,17 @@ vi.mock('ink', async (importOriginal) => { }; }); +import { InputContext, type InputState } from './contexts/InputContext.js'; + // Helper component will read the context values provided by AppContainer // so we can assert against them in our tests. let capturedUIState: UIState; +let capturedInputState: InputState; let capturedUIActions: UIActions; let capturedOverflowActions: OverflowActions; function TestContextConsumer() { capturedUIState = useContext(UIStateContext)!; + capturedInputState = useContext(InputContext)!; capturedUIActions = useContext(UIActionsContext)!; capturedOverflowActions = useOverflowActions()!; return null; @@ -3036,7 +3040,7 @@ describe('AppContainer State Management', () => { }); const { unmount } = await act(async () => renderAppContainer()); - expect(capturedUIState.userMessages).toContain('previous message'); + expect(capturedInputState.userMessages).toContain('previous message'); const { onCancelSubmit } = extractUseGeminiStreamArgs( mockedUseGeminiStream.mock.lastCall!, @@ -3064,8 +3068,8 @@ describe('AppContainer State Management', () => { const { rerender, unmount } = await act(async () => renderAppContainer()); // Verify userMessages is populated from inputHistory - expect(capturedUIState.userMessages).toContain('first prompt'); - expect(capturedUIState.userMessages).toContain('second prompt'); + expect(capturedInputState.userMessages).toContain('first prompt'); + expect(capturedInputState.userMessages).toContain('second prompt'); // Clear the conversation history (simulating /clear command) const mockClearItems = vi.fn(); @@ -3084,8 +3088,8 @@ describe('AppContainer State Management', () => { // Verify that userMessages still contains the input history // (it should not be affected by clearing conversation history) - expect(capturedUIState.userMessages).toContain('first prompt'); - expect(capturedUIState.userMessages).toContain('second prompt'); + expect(capturedInputState.userMessages).toContain('first prompt'); + expect(capturedInputState.userMessages).toContain('second prompt'); unmount(); }); diff --git a/packages/cli/src/ui/AppContainer.tsx b/packages/cli/src/ui/AppContainer.tsx index 07af8a5b0a..d5c84a1f2f 100644 --- a/packages/cli/src/ui/AppContainer.tsx +++ b/packages/cli/src/ui/AppContainer.tsx @@ -194,6 +194,8 @@ import { } from './hooks/useVisibilityToggle.js'; import { useKeyMatchers } from './hooks/useKeyMatchers.js'; +import { InputContext } from './contexts/InputContext.js'; + /** * The fraction of the terminal width to allocate to the shell. * This provides horizontal padding. @@ -2326,6 +2328,27 @@ Logging in with Google... Restarting Gemini CLI to continue. }; }, [config, refreshStatic]); + const inputState = useMemo( + () => ({ + buffer, + userMessages: inputHistory, + shellModeActive, + showEscapePrompt, + copyModeEnabled, + inputWidth, + suggestionsWidth, + }), + [ + buffer, + inputHistory, + shellModeActive, + showEscapePrompt, + copyModeEnabled, + inputWidth, + suggestionsWidth, + ], + ); + const uiState: UIState = useMemo( () => ({ history: historyManager.history, @@ -2369,11 +2392,6 @@ Logging in with Google... Restarting Gemini CLI to continue. initError, pendingGeminiHistoryItems, thought, - shellModeActive, - userMessages: inputHistory, - buffer, - inputWidth, - suggestionsWidth, isInputActive, isResuming, shouldShowIdePrompt, @@ -2389,7 +2407,6 @@ Logging in with Google... Restarting Gemini CLI to continue. renderMarkdown, ctrlCPressedOnce: ctrlCPressCount >= 1, ctrlDPressedOnce: ctrlDPressCount >= 1, - showEscapePrompt, shortcutsHelpVisible, cleanUiDetailsVisible, isFocused, @@ -2441,7 +2458,6 @@ Logging in with Google... Restarting Gemini CLI to continue. embeddedShellFocused, showDebugProfiler, customDialog, - copyModeEnabled, transientMessage, bannerData, bannerVisible, @@ -2496,11 +2512,6 @@ Logging in with Google... Restarting Gemini CLI to continue. initError, pendingGeminiHistoryItems, thought, - shellModeActive, - inputHistory, - buffer, - inputWidth, - suggestionsWidth, isInputActive, isResuming, shouldShowIdePrompt, @@ -2516,7 +2527,6 @@ Logging in with Google... Restarting Gemini CLI to continue. renderMarkdown, ctrlCPressCount, ctrlDPressCount, - showEscapePrompt, shortcutsHelpVisible, cleanUiDetailsVisible, isFocused, @@ -2568,7 +2578,6 @@ Logging in with Google... Restarting Gemini CLI to continue. customDialog, apiKeyDefaultValue, authState, - copyModeEnabled, transientMessage, bannerData, bannerVisible, @@ -2755,32 +2764,34 @@ Logging in with Google... Restarting Gemini CLI to continue. return ( - - - - + + + - - - - - - - - - - - + + + + + + + + + + + + + ); }; diff --git a/packages/cli/src/ui/__snapshots__/App.test.tsx.snap b/packages/cli/src/ui/__snapshots__/App.test.tsx.snap index f9799c2b07..94b1f9b1a4 100644 --- a/packages/cli/src/ui/__snapshots__/App.test.tsx.snap +++ b/packages/cli/src/ui/__snapshots__/App.test.tsx.snap @@ -124,13 +124,14 @@ HistoryItemDisplay │ │ │ ? ls list directory │ │ │ -│ ls │ -│ Allow execution of: 'ls'? │ +│ ╭──────────────────────────────────────────────────────────────────────────────────────────────╮ │ +│ │ ls │ │ +│ ╰──────────────────────────────────────────────────────────────────────────────────────────────╯ │ +│ Allow execution of [ls]? │ │ │ │ ● 1. Allow once │ │ 2. Allow for this session │ │ 3. No, suggest changes (esc) │ -│ │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ @@ -138,7 +139,6 @@ HistoryItemDisplay - Notifications Composer diff --git a/packages/cli/src/ui/__snapshots__/ToolConfirmationFullFrame-Full-Terminal-Tool-Confirmation-Snapshot-renders-tool-confirmation-box-in-the-frame-of-the-entire-terminal.snap.svg b/packages/cli/src/ui/__snapshots__/ToolConfirmationFullFrame-Full-Terminal-Tool-Confirmation-Snapshot-renders-tool-confirmation-box-in-the-frame-of-the-entire-terminal.snap.svg index b83d79928c..7565185d93 100644 --- a/packages/cli/src/ui/__snapshots__/ToolConfirmationFullFrame-Full-Terminal-Tool-Confirmation-Snapshot-renders-tool-confirmation-box-in-the-frame-of-the-entire-terminal.snap.svg +++ b/packages/cli/src/ui/__snapshots__/ToolConfirmationFullFrame-Full-Terminal-Tool-Confirmation-Snapshot-renders-tool-confirmation-box-in-the-frame-of-the-entire-terminal.snap.svg @@ -12,253 +12,283 @@ ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄ - ╭─────────────────────────────────────────────────────────────────────────────────────────────────╮ - │ - Action Required - │ - │ - │ - │ - ? - Edit - packages/.../InputPrompt.tsx: return kittyProtocolSupporte... => return kittyProto - … - │ - │ - │ - │ - ... first 44 lines hidden (Ctrl+O to show) ... - │ - │ - 45 - const - line45 - = - true - ; - │ - │ - 46 - const - line46 - = - true - ; - │ - │ - 47 - const - line47 - = - true - ; - │ - ▄ - │ - 48 - const - line48 - = - true - ; - │ - █ - │ - 49 - const - line49 - = - true - ; - │ - █ - │ - 50 - const - line50 - = - true - ; - │ - █ - │ - 51 - const - line51 - = - true - ; - │ - █ - │ - 52 - const - line52 - = - true - ; - │ - █ - │ - 53 - const - line53 - = - true - ; - │ - █ - │ - 54 - const - line54 - = - true - ; - │ - █ - │ - 55 - const - line55 - = - true - ; - │ - █ - │ - 56 - const - line56 - = - true - ; - │ - █ - │ - 57 - const - line57 - = - true - ; - │ - █ - │ - 58 - const - line58 - = - true - ; - │ - █ - │ - 59 - const - line59 - = - true - ; - │ - █ - │ - 60 - const - line60 - = - true - ; - │ - █ - │ - - 61 - - - - + ╭─────────────────────────────────────────────────────────────────────────────────────────────────╮ + │ + ? Edit + │ + │ + ╭─────────────────────────────────────────────────────────────────────────────────────────────╮ + │ + │ + │ + ... first 42 lines hidden (Ctrl+O to show) ... + │ + │ + │ + │ + 43 + const + line43 + = + true + ; + │ + │ + │ + │ + 44 + const + line44 + = + true + ; + │ + │ + │ + │ + 45 + const + line45 + = + true + ; + │ + │ + │ + │ + 46 + const + line46 + = + true + ; + │ + │ + │ + │ + 47 + const + line47 + = + true + ; + │ + │▄ + │ + │ + 48 + const + line48 + = + true + ; + │ + │█ + │ + │ + 49 + const + line49 + = + true + ; + │ + │█ + │ + │ + 50 + const + line50 + = + true + ; + │ + │█ + │ + │ + 51 + const + line51 + = + true + ; + │ + │█ + │ + │ + 52 + const + line52 + = + true + ; + │ + │█ + │ + │ + 53 + const + line53 + = + true + ; + │ + │█ + │ + │ + 54 + const + line54 + = + true + ; + │ + │█ + │ + │ + 55 + const + line55 + = + true + ; + │ + │█ + │ + │ + 56 + const + line56 + = + true + ; + │ + │█ + │ + │ + 57 + const + line57 + = + true + ; + │ + │█ + │ + │ + 58 + const + line58 + = + true + ; + │ + │█ + │ + │ + 59 + const + line59 + = + true + ; + │ + │█ + │ + │ + 60 + const + line60 + = + true + ; + │ + │█ + │ + │ + + 61 - - return - - kittyProtocolSupporte...; - │ - █ - │ - - 61 - - - + + - + + + + return + + kittyProtocolSupporte...; + │ + │█ + │ + │ + + 61 - - return - - kittyProtocolSupporte...; - │ - █ - │ - 62 - buffer: TextBuffer; - │ - █ - │ - 63 - onSubmit - : ( - value - : - string - ) => - void - ; - │ - █ - │ - Apply this change? - │ - █ - │ - │ - █ - │ - - ● - - - 1. - - - Allow once - - │ - █ - │ - 2. - Allow for this session - │ - █ - │ - 3. - Allow for this file in all future sessions - │ - █ - │ - 4. - Modify with external editor - │ - █ - │ - 5. - No, suggest changes (esc) - │ - █ - │ - │ - █ - ╰─────────────────────────────────────────────────────────────────────────────────────────────────╯ - █ + + + + + + return + + kittyProtocolSupporte...; + │ + │█ + │ + │ + 62 + buffer: TextBuffer; + │ + │█ + │ + │ + 63 + onSubmit + : ( + value + : + string + ) => + void + ; + │ + │█ + │ + ╰─────────────────────────────────────────────────────────────────────────────────────────────╯ + │█ + │ + Apply this change? + │█ + │ + │█ + │ + + ● + + + 1. + + + Allow once + + │█ + │ + 2. + Allow for this session + │█ + │ + 3. + Allow for this file in all future sessions + ~/.gemini/policies/auto-saved.toml + │█ + │ + 4. + Modify with external editor + │█ + │ + 5. + No, suggest changes (esc) + │█ + ╰─────────────────────────────────────────────────────────────────────────────────────────────────╯█ \ No newline at end of file diff --git a/packages/cli/src/ui/__snapshots__/ToolConfirmationFullFrame.test.tsx.snap b/packages/cli/src/ui/__snapshots__/ToolConfirmationFullFrame.test.tsx.snap index 6841182785..d9cc9f7ce3 100644 --- a/packages/cli/src/ui/__snapshots__/ToolConfirmationFullFrame.test.tsx.snap +++ b/packages/cli/src/ui/__snapshots__/ToolConfirmationFullFrame.test.tsx.snap @@ -5,39 +5,39 @@ exports[`Full Terminal Tool Confirmation Snapshot > renders tool confirmation bo ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄ ╭─────────────────────────────────────────────────────────────────────────────────────────────────╮ -│ Action Required │ -│ │ -│ ? Edit packages/.../InputPrompt.tsx: return kittyProtocolSupporte... => return kittyProto… │ -│ │ -│ ... first 44 lines hidden (Ctrl+O to show) ... │ -│ 45 const line45 = true; │ -│ 46 const line46 = true; │ -│ 47 const line47 = true; │▄ -│ 48 const line48 = true; │█ -│ 49 const line49 = true; │█ -│ 50 const line50 = true; │█ -│ 51 const line51 = true; │█ -│ 52 const line52 = true; │█ -│ 53 const line53 = true; │█ -│ 54 const line54 = true; │█ -│ 55 const line55 = true; │█ -│ 56 const line56 = true; │█ -│ 57 const line57 = true; │█ -│ 58 const line58 = true; │█ -│ 59 const line59 = true; │█ -│ 60 const line60 = true; │█ -│ 61 - return kittyProtocolSupporte...; │█ -│ 61 + return kittyProtocolSupporte...; │█ -│ 62 buffer: TextBuffer; │█ -│ 63 onSubmit: (value: string) => void; │█ +│ ? Edit │ +│ ╭─────────────────────────────────────────────────────────────────────────────────────────────╮ │ +│ │ ... first 42 lines hidden (Ctrl+O to show) ... │ │ +│ │ 43 const line43 = true; │ │ +│ │ 44 const line44 = true; │ │ +│ │ 45 const line45 = true; │ │ +│ │ 46 const line46 = true; │ │ +│ │ 47 const line47 = true; │ │▄ +│ │ 48 const line48 = true; │ │█ +│ │ 49 const line49 = true; │ │█ +│ │ 50 const line50 = true; │ │█ +│ │ 51 const line51 = true; │ │█ +│ │ 52 const line52 = true; │ │█ +│ │ 53 const line53 = true; │ │█ +│ │ 54 const line54 = true; │ │█ +│ │ 55 const line55 = true; │ │█ +│ │ 56 const line56 = true; │ │█ +│ │ 57 const line57 = true; │ │█ +│ │ 58 const line58 = true; │ │█ +│ │ 59 const line59 = true; │ │█ +│ │ 60 const line60 = true; │ │█ +│ │ 61 - return kittyProtocolSupporte...; │ │█ +│ │ 61 + return kittyProtocolSupporte...; │ │█ +│ │ 62 buffer: TextBuffer; │ │█ +│ │ 63 onSubmit: (value: string) => void; │ │█ +│ ╰─────────────────────────────────────────────────────────────────────────────────────────────╯ │█ │ Apply this change? │█ │ │█ │ ● 1. Allow once │█ │ 2. Allow for this session │█ -│ 3. Allow for this file in all future sessions │█ +│ 3. Allow for this file in all future sessions ~/.gemini/policies/auto-saved.toml │█ │ 4. Modify with external editor │█ │ 5. No, suggest changes (esc) │█ -│ │█ ╰─────────────────────────────────────────────────────────────────────────────────────────────────╯█ " `; diff --git a/packages/cli/src/ui/components/AnsiOutput.test.tsx b/packages/cli/src/ui/components/AnsiOutput.test.tsx index 6331c149a8..04d6ccb0d9 100644 --- a/packages/cli/src/ui/components/AnsiOutput.test.tsx +++ b/packages/cli/src/ui/components/AnsiOutput.test.tsx @@ -16,6 +16,7 @@ const createAnsiToken = (overrides: Partial): AnsiToken => ({ underline: false, dim: false, inverse: false, + isUninitialized: false, fg: '#ffffff', bg: '#000000', ...overrides, diff --git a/packages/cli/src/ui/components/AppHeader.tsx b/packages/cli/src/ui/components/AppHeader.tsx index 7d0ef75a36..1b3d9b2cfa 100644 --- a/packages/cli/src/ui/components/AppHeader.tsx +++ b/packages/cli/src/ui/components/AppHeader.tsx @@ -59,13 +59,20 @@ const NARROW_TERMINAL_BREAKPOINT = 60; export const AppHeader = ({ version, showDetails = true }: AppHeaderProps) => { const settings = useSettings(); const config = useConfig(); - const { terminalWidth, bannerData, bannerVisible, updateInfo } = useUIState(); + const { + terminalWidth, + bannerData, + bannerVisible, + updateInfo, + isConfigInitialized, + isAuthenticating, + } = useUIState(); const { bannerText } = useBanner(bannerData); const { showTips } = useTips(); const authType = config.getContentGeneratorConfig()?.authType; - const loggedOut = !authType; + const loggedOut = isConfigInitialized && !isAuthenticating && !authType; const showHeader = !( settings.merged.ui.hideBanner || config.getScreenReader() diff --git a/packages/cli/src/ui/components/Composer.test.tsx b/packages/cli/src/ui/components/Composer.test.tsx index 1750536dbe..316b9a1780 100644 --- a/packages/cli/src/ui/components/Composer.test.tsx +++ b/packages/cli/src/ui/components/Composer.test.tsx @@ -245,20 +245,37 @@ const createMockConfig = (overrides = {}): Config => ...overrides, }) as unknown as Config; +import { InputContext, type InputState } from '../contexts/InputContext.js'; + const renderComposer = async ( uiState: UIState, settings = createMockSettings({ ui: {} }), config = createMockConfig(), uiActions = createMockUIActions(), + inputStateOverrides: Partial = {}, ) => { + const inputState = { + buffer: { text: '' } as unknown as TextBuffer, + userMessages: [], + shellModeActive: false, + showEscapePrompt: false, + copyModeEnabled: false, + inputWidth: 80, + suggestionsWidth: 40, + ...(uiState as unknown as Partial), + ...inputStateOverrides, + }; + const result = await render( - - - - - + + + + + + + , ); @@ -541,7 +558,6 @@ describe('Composer', () => { const uiState = createMockUIState({ ctrlCPressedOnce: false, ctrlDPressedOnce: false, - showEscapePrompt: false, }); const { lastFrame } = await renderComposer(uiState); @@ -631,7 +647,6 @@ describe('Composer', () => { async (mode) => { const uiState = createMockUIState({ showApprovalModeIndicator: mode, - shellModeActive: false, }); const { lastFrame } = await renderComposer(uiState); @@ -641,11 +656,15 @@ describe('Composer', () => { ); it('shows ShellModeIndicator when shell mode is active', async () => { - const uiState = createMockUIState({ - shellModeActive: true, - }); + const uiState = createMockUIState(); - const { lastFrame } = await renderComposer(uiState); + const { lastFrame } = await renderComposer( + uiState, + undefined, + undefined, + undefined, + { shellModeActive: true }, + ); expect(lastFrame()).toMatch(/ShellModeIndic[\s\S]*tor/); }); @@ -724,11 +743,16 @@ describe('Composer', () => { it('shows Esc rewind prompt in minimal mode without showing full UI', async () => { const uiState = createMockUIState({ cleanUiDetailsVisible: false, - showEscapePrompt: true, history: [{ id: 1, type: 'user', text: 'msg' }], }); - const { lastFrame } = await renderComposer(uiState); + const { lastFrame } = await renderComposer( + uiState, + undefined, + undefined, + undefined, + { showEscapePrompt: true }, + ); const output = lastFrame(); expect(output).toContain('Press Esc again to rewind.'); expect(output).not.toContain('ContextSummaryDisplay'); @@ -828,11 +852,16 @@ describe('Composer', () => { describe('Shortcuts Hint', () => { it('restores shortcuts hint after 200ms debounce when buffer is empty', async () => { const uiState = createMockUIState({ - buffer: { text: '' } as unknown as TextBuffer, cleanUiDetailsVisible: false, }); - const { lastFrame } = await renderComposer(uiState); + const { lastFrame } = await renderComposer( + uiState, + undefined, + undefined, + undefined, + { buffer: { text: '' } as unknown as TextBuffer }, + ); await act(async () => { await vi.advanceTimersByTimeAsync(250); @@ -845,11 +874,16 @@ describe('Composer', () => { it('hides shortcuts hint when text is typed in buffer', async () => { const uiState = createMockUIState({ - buffer: { text: 'hello' } as unknown as TextBuffer, cleanUiDetailsVisible: false, }); - const { lastFrame } = await renderComposer(uiState); + const { lastFrame } = await renderComposer( + uiState, + undefined, + undefined, + undefined, + { buffer: { text: 'hello' } as unknown as TextBuffer }, + ); expect(lastFrame()).not.toContain('press tab twice for more'); expect(lastFrame()).not.toContain('? for shortcuts'); diff --git a/packages/cli/src/ui/components/Composer.tsx b/packages/cli/src/ui/components/Composer.tsx index 4a1647d11b..52bb2b294f 100644 --- a/packages/cli/src/ui/components/Composer.tsx +++ b/packages/cli/src/ui/components/Composer.tsx @@ -9,6 +9,7 @@ import { useState, useEffect } from 'react'; import { useConfig } from '../contexts/ConfigContext.js'; import { useSettings } from '../contexts/SettingsContext.js'; import { useUIState } from '../contexts/UIStateContext.js'; +import { useInputState } from '../contexts/InputContext.js'; import { useUIActions } from '../contexts/UIActionsContext.js'; import { useVimMode } from '../contexts/VimModeContext.js'; import { useAlternateBuffer } from '../hooks/useAlternateBuffer.js'; @@ -30,6 +31,7 @@ import { appEvents, AppEvent } from '../../utils/events.js'; export const Composer = ({ isFocused = true }: { isFocused?: boolean }) => { const uiState = useUIState(); + const inputState = useInputState(); const uiActions = useUIActions(); const settings = useSettings(); const config = useConfig(); @@ -81,12 +83,12 @@ export const Composer = ({ isFocused = true }: { isFocused?: boolean }) => { return null; } - const hasToast = shouldShowToast(uiState); + const showToast = shouldShowToast(uiState, inputState); const hideUiDetailsForSuggestions = suggestionsVisible && suggestionsPosition === 'above'; // Mini Mode VIP Flags (Pure Content Triggers) - const showMinimalToast = hasToast; + const showMinimalToast = showToast; return ( { {uiState.isInputActive && ( { ? vimMode === 'INSERT' ? " Press 'Esc' for NORMAL mode." : " Press 'i' for INSERT mode." - : uiState.shellModeActive + : inputState.shellModeActive ? ' Type your shell command' : ' Type your message or @path/to/file' } @@ -173,7 +170,6 @@ export const Composer = ({ isFocused = true }: { isFocused?: boolean }) => { streamingState={uiState.streamingState} suggestionsPosition={suggestionsPosition} onSuggestionsVisibilityChange={setSuggestionsVisible} - copyModeEnabled={uiState.copyModeEnabled} /> )} diff --git a/packages/cli/src/ui/components/CopyModeWarning.test.tsx b/packages/cli/src/ui/components/CopyModeWarning.test.tsx index cc20a142dd..c1b797ffd5 100644 --- a/packages/cli/src/ui/components/CopyModeWarning.test.tsx +++ b/packages/cli/src/ui/components/CopyModeWarning.test.tsx @@ -4,34 +4,36 @@ * SPDX-License-Identifier: Apache-2.0 */ -import { render } from '../../test-utils/render.js'; import { CopyModeWarning } from './CopyModeWarning.js'; import { describe, it, expect, vi, beforeEach } from 'vitest'; -import { useUIState, type UIState } from '../contexts/UIStateContext.js'; +import { renderWithProviders } from '../../test-utils/render.js'; +import { useInputState } from '../contexts/InputContext.js'; -vi.mock('../contexts/UIStateContext.js'); +vi.mock('../contexts/InputContext.js'); describe('CopyModeWarning', () => { - const mockUseUIState = vi.mocked(useUIState); - beforeEach(() => { vi.clearAllMocks(); }); it('renders nothing when copy mode is disabled', async () => { - mockUseUIState.mockReturnValue({ + vi.mocked(useInputState).mockReturnValue({ copyModeEnabled: false, - } as unknown as UIState); - const { lastFrame, unmount } = await render(); + } as unknown as ReturnType); + const { lastFrame, unmount } = await renderWithProviders( + , + ); expect(lastFrame({ allowEmpty: true })).toBe(''); unmount(); }); it('renders warning when copy mode is enabled', async () => { - mockUseUIState.mockReturnValue({ + vi.mocked(useInputState).mockReturnValue({ copyModeEnabled: true, - } as unknown as UIState); - const { lastFrame, unmount } = await render(); + } as unknown as ReturnType); + const { lastFrame, unmount } = await renderWithProviders( + , + ); expect(lastFrame()).toContain('In Copy Mode'); expect(lastFrame()).toContain('Use Page Up/Down to scroll'); expect(lastFrame()).toContain('Press Ctrl+S or any other key to exit'); diff --git a/packages/cli/src/ui/components/CopyModeWarning.tsx b/packages/cli/src/ui/components/CopyModeWarning.tsx index eb5c1f6d78..2eec1b62ae 100644 --- a/packages/cli/src/ui/components/CopyModeWarning.tsx +++ b/packages/cli/src/ui/components/CopyModeWarning.tsx @@ -6,11 +6,11 @@ import type React from 'react'; import { Box, Text } from 'ink'; -import { useUIState } from '../contexts/UIStateContext.js'; +import { useInputState } from '../contexts/InputContext.js'; import { theme } from '../semantic-colors.js'; export const CopyModeWarning: React.FC = () => { - const { copyModeEnabled } = useUIState(); + const { copyModeEnabled } = useInputState(); return ( diff --git a/packages/cli/src/ui/components/ExitPlanModeDialog.test.tsx b/packages/cli/src/ui/components/ExitPlanModeDialog.test.tsx index 523f15516c..18f2f02224 100644 --- a/packages/cli/src/ui/components/ExitPlanModeDialog.test.tsx +++ b/packages/cli/src/ui/components/ExitPlanModeDialog.test.tsx @@ -169,6 +169,11 @@ Implement a comprehensive authentication system with multiple providers. getUseTerminalBuffer: () => false, } as unknown as import('@google/gemini-cli-core').Config, settings: createMockSettings({ ui: { useAlternateBuffer } }), + inputState: { + buffer: { text: '' } as never, + showEscapePrompt: false, + shellModeActive: false, + }, }, ); }; @@ -472,6 +477,11 @@ Implement a comprehensive authentication system with multiple providers. settings: createMockSettings({ ui: { useAlternateBuffer: useAlternateBuffer ?? true }, }), + inputState: { + buffer: { text: '' } as never, + showEscapePrompt: false, + shellModeActive: false, + }, }, ), ); diff --git a/packages/cli/src/ui/components/Footer.tsx b/packages/cli/src/ui/components/Footer.tsx index 6719ae7c82..0696334577 100644 --- a/packages/cli/src/ui/components/Footer.tsx +++ b/packages/cli/src/ui/components/Footer.tsx @@ -26,6 +26,7 @@ import { useUIState } from '../contexts/UIStateContext.js'; import { useConfig } from '../contexts/ConfigContext.js'; import { useSettings } from '../contexts/SettingsContext.js'; import { useVimMode } from '../contexts/VimModeContext.js'; +import { useInputState } from '../contexts/InputContext.js'; import { ALL_ITEMS, type FooterItemId, @@ -173,6 +174,7 @@ interface FooterColumn { export const Footer: React.FC = () => { const uiState = useUIState(); + const { copyModeEnabled } = useInputState(); const config = useConfig(); const settings = useSettings(); const { vimEnabled, vimMode } = useVimMode(); @@ -365,10 +367,7 @@ export const Footer: React.FC = () => { id, header, () => ( - + ), 10, ); diff --git a/packages/cli/src/ui/components/InputPrompt.test.tsx b/packages/cli/src/ui/components/InputPrompt.test.tsx index 49dd08ac53..4d40809837 100644 --- a/packages/cli/src/ui/components/InputPrompt.test.tsx +++ b/packages/cli/src/ui/components/InputPrompt.test.tsx @@ -4,16 +4,17 @@ * SPDX-License-Identifier: Apache-2.0 */ -import { renderWithProviders } from '../../test-utils/render.js'; +import { renderWithProviders, cleanup } from '../../test-utils/render.js'; import { createMockSettings } from '../../test-utils/settings.js'; import { makeFakeConfig } from '@google/gemini-cli-core'; import { waitFor } from '../../test-utils/async.js'; -import { act, useState } from 'react'; +import { act, useState, useMemo } from 'react'; import { InputPrompt, tryTogglePasteExpansion, type InputPromptProps, } from './InputPrompt.js'; +import { InputContext } from '../contexts/InputContext.js'; import { calculateTransformationsForLine, calculateTransformedLine, @@ -22,6 +23,7 @@ import { import { ApprovalMode, debugLogger, + coreEvents, type Config, } from '@google/gemini-cli-core'; import * as path from 'node:path'; @@ -92,6 +94,8 @@ vi.mock('ink', async (importOriginal) => { afterEach(() => { vi.restoreAllMocks(); + vi.useRealTimers(); + cleanup(); }); const mockSlashCommands: SlashCommand[] = [ @@ -154,8 +158,47 @@ const mockSlashCommands: SlashCommand[] = [ }, ]; +export type TestInputPromptProps = InputPromptProps & { + buffer: TextBuffer; + userMessages: string[]; + shellModeActive: boolean; + copyModeEnabled?: boolean; + showEscapePrompt?: boolean; + inputWidth: number; + suggestionsWidth: number; +}; + +const TestInputPrompt = (props: TestInputPromptProps) => { + const contextValue = useMemo( + () => ({ + buffer: props.buffer, + userMessages: props.userMessages, + shellModeActive: props.shellModeActive, + copyModeEnabled: props.copyModeEnabled, + showEscapePrompt: props.showEscapePrompt || false, + inputWidth: props.inputWidth, + suggestionsWidth: props.suggestionsWidth, + }), + [ + props.buffer, + props.userMessages, + props.shellModeActive, + props.copyModeEnabled, + props.showEscapePrompt, + props.inputWidth, + props.suggestionsWidth, + ], + ); + + return ( + + + + ); +}; + describe('InputPrompt', () => { - let props: InputPromptProps; + let props: TestInputPromptProps; let mockShellHistory: UseShellHistoryReturn; let mockCommandCompletion: UseCommandCompletionReturn; let mockInputHistory: UseInputHistoryReturn; @@ -196,6 +239,7 @@ describe('InputPrompt', () => { beforeEach(() => { vi.resetAllMocks(); + coreEvents.removeAllListeners(); vi.spyOn( terminalCapabilityManager, 'isKittyProtocolEnabled', @@ -220,6 +264,7 @@ describe('InputPrompt', () => { col = newText.length; } mockBuffer.cursor = [0, col]; + mockBuffer.allVisualLines = [newText]; mockBuffer.viewportVisualLines = [newText]; mockBuffer.allVisualLines = [newText]; mockBuffer.visualToLogicalMap = [[0, 0]]; @@ -386,7 +431,7 @@ describe('InputPrompt', () => { it('should call shellHistory.getPreviousCommand on up arrow in shell mode', async () => { props.shellModeActive = true; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -404,7 +449,7 @@ describe('InputPrompt', () => { it('should call shellHistory.getNextCommand on down arrow in shell mode', async () => { props.shellModeActive = true; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -425,7 +470,7 @@ describe('InputPrompt', () => { 'previous command', ); const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -445,7 +490,7 @@ describe('InputPrompt', () => { props.shellModeActive = true; props.buffer.setText('ls -l'); const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -478,7 +523,7 @@ describe('InputPrompt', () => { }); const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -512,7 +557,7 @@ describe('InputPrompt', () => { }); const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -539,7 +584,7 @@ describe('InputPrompt', () => { it('should NOT call shell history methods when not in shell mode', async () => { props.buffer.setText('some text'); const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -577,7 +622,7 @@ describe('InputPrompt', () => { mockBuffer.visualScrollRow = 0; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -600,7 +645,7 @@ describe('InputPrompt', () => { mockBuffer.visualScrollRow = 0; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -623,7 +668,7 @@ describe('InputPrompt', () => { mockBuffer.visualScrollRow = 0; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -646,7 +691,7 @@ describe('InputPrompt', () => { mockBuffer.visualScrollRow = 0; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -677,7 +722,7 @@ describe('InputPrompt', () => { props.buffer.setText('/mem'); const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -714,7 +759,7 @@ describe('InputPrompt', () => { props.buffer.setText('/mem'); const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -746,7 +791,7 @@ describe('InputPrompt', () => { }); props.buffer.setText('some text'); const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -779,7 +824,7 @@ describe('InputPrompt', () => { it('should clear the buffer and reset completion on Ctrl+C', async () => { mockBuffer.text = 'some text'; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -812,7 +857,7 @@ describe('InputPrompt', () => { ); const { stdin, unmount } = await renderWithProviders( - , + , ); // Send Ctrl+V @@ -836,7 +881,7 @@ describe('InputPrompt', () => { vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(false); const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -855,7 +900,7 @@ describe('InputPrompt', () => { vi.mocked(clipboardUtils.saveClipboardImage).mockResolvedValue(null); const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -885,7 +930,7 @@ describe('InputPrompt', () => { mockBuffer.replaceRangeByOffset = vi.fn(); const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -916,7 +961,7 @@ describe('InputPrompt', () => { ); const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -942,7 +987,7 @@ describe('InputPrompt', () => { vi.mocked(mockBuffer.replaceRangeByOffset).mockClear(); const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -966,7 +1011,7 @@ describe('InputPrompt', () => { }); const { stdout, stdin, unmount } = await renderWithProviders( - , + , { settings }, ); @@ -1025,7 +1070,7 @@ describe('InputPrompt', () => { }); props.buffer.setText(bufferText); const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1050,7 +1095,7 @@ describe('InputPrompt', () => { props.buffer.setText('/mem'); const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1087,7 +1132,7 @@ describe('InputPrompt', () => { props.buffer.setText('/?'); const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1107,7 +1152,7 @@ describe('InputPrompt', () => { props.streamingState = StreamingState.Responding; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1129,7 +1174,7 @@ describe('InputPrompt', () => { props.streamingState = StreamingState.Responding; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1154,7 +1199,7 @@ describe('InputPrompt', () => { props.streamingState = StreamingState.Responding; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1176,7 +1221,7 @@ describe('InputPrompt', () => { props.buffer.setText(' '); // Set buffer to whitespace const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1201,7 +1246,7 @@ describe('InputPrompt', () => { props.buffer.setText('/clear'); const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1228,7 +1273,7 @@ describe('InputPrompt', () => { props.buffer.text = '/review'; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1258,7 +1303,7 @@ describe('InputPrompt', () => { props.buffer.text = '/review'; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1286,7 +1331,7 @@ describe('InputPrompt', () => { props.buffer.setText('/clear'); const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1311,7 +1356,7 @@ describe('InputPrompt', () => { props.buffer.text = '@file.txt'; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1340,7 +1385,7 @@ describe('InputPrompt', () => { props.buffer.text = '@file.txt'; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1390,7 +1435,7 @@ describe('InputPrompt', () => { props.buffer.cursor = [0, 3]; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1434,7 +1479,7 @@ describe('InputPrompt', () => { props.buffer.cursor = [0, 3]; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1477,7 +1522,7 @@ describe('InputPrompt', () => { props.buffer.cursor = [0, 3]; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1511,7 +1556,7 @@ describe('InputPrompt', () => { props.buffer.cursor = [0, 3]; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1553,7 +1598,7 @@ describe('InputPrompt', () => { props.buffer.cursor = [0, 5]; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1605,7 +1650,7 @@ describe('InputPrompt', () => { props.buffer.cursor = [0, 10]; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1662,7 +1707,7 @@ describe('InputPrompt', () => { props.buffer.cursor = [0, 19]; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1714,7 +1759,7 @@ describe('InputPrompt', () => { props.buffer.cursor = [0, 10]; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1742,7 +1787,7 @@ describe('InputPrompt', () => { props.buffer.setText('@src/components/'); const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1765,7 +1810,7 @@ describe('InputPrompt', () => { mockBuffer.lines = ['first line\\']; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1788,7 +1833,7 @@ describe('InputPrompt', () => { props.buffer.setText('some text to clear'); }); const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1808,7 +1853,7 @@ describe('InputPrompt', () => { it('should render correctly in plan mode', async () => { props.approvalMode = ApprovalMode.PLAN; const { stdout, unmount } = await renderWithProviders( - , + , ); await waitFor(() => { @@ -1825,7 +1870,7 @@ describe('InputPrompt', () => { it('should NOT clear the buffer on Ctrl+C if it is empty', async () => { props.buffer.text = ''; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1843,7 +1888,7 @@ describe('InputPrompt', () => { it('should call setBannerVisible(false) when clear screen key is pressed', async () => { const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -1870,7 +1915,7 @@ describe('InputPrompt', () => { it('should render with background color by default', async () => { const { stdout, unmount } = await renderWithProviders( - , + , ); await waitFor(() => { @@ -1894,7 +1939,7 @@ describe('InputPrompt', () => { vi.mocked(isLowColorDepth).mockReturnValue(true); const { stdout, unmount } = await renderWithProviders( - , + , { uiState: { terminalBackgroundColor: color, @@ -1930,7 +1975,7 @@ describe('InputPrompt', () => { vi.mocked(isLowColorDepth).mockReturnValue(true); const { stdout, unmount } = await renderWithProviders( - , + , { uiState: { terminalBackgroundColor: '#333333', @@ -1953,7 +1998,7 @@ describe('InputPrompt', () => { vi.mocked(isLowColorDepth).mockReturnValue(true); const { stdout, unmount } = await renderWithProviders( - , + , { uiState: { terminalBackgroundColor: 'black', @@ -1976,7 +2021,7 @@ describe('InputPrompt', () => { vi.mocked(isLowColorDepth).mockReturnValue(true); const { stdout, unmount } = await renderWithProviders( - , + , { uiState: { @@ -2011,7 +2056,7 @@ describe('InputPrompt', () => { it('should render with plain borders when useBackgroundColor is false', async () => { props.config.getUseBackgroundColor = () => false; const { stdout, unmount } = await renderWithProviders( - , + , ); await waitFor(() => { @@ -2119,7 +2164,7 @@ describe('InputPrompt', () => { }); const { unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -2162,7 +2207,7 @@ describe('InputPrompt', () => { ])('$name', async ({ vimHandled, expectBufferHandleInput }) => { props.vimHandleInput = vi.fn().mockReturnValue(vimHandled); const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => stdin.write('i')); @@ -2182,7 +2227,7 @@ describe('InputPrompt', () => { it('should handle bracketed paste when not focused', async () => { props.focus = false; const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -2202,7 +2247,7 @@ describe('InputPrompt', () => { it('should ignore regular keypresses when not focused', async () => { props.focus = false; const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -2273,12 +2318,13 @@ describe('InputPrompt', () => { async ({ text, visualCursor }) => { mockBuffer.text = text; mockBuffer.lines = [text]; + mockBuffer.allVisualLines = [text]; mockBuffer.viewportVisualLines = [text]; mockBuffer.visualCursor = visualCursor as [number, number]; props.config.getUseBackgroundColor = () => false; const renderResult = await renderWithProviders( - , + , ); await renderResult.waitUntilReady(); await expect(renderResult).toMatchSvgSnapshot(); @@ -2322,6 +2368,7 @@ describe('InputPrompt', () => { async ({ text, visualCursor, visualToLogicalMap }) => { mockBuffer.text = text; mockBuffer.lines = text.split('\n'); + mockBuffer.allVisualLines = text.split('\n'); mockBuffer.viewportVisualLines = text.split('\n'); mockBuffer.visualCursor = visualCursor as [number, number]; mockBuffer.visualToLogicalMap = visualToLogicalMap as Array< @@ -2330,7 +2377,7 @@ describe('InputPrompt', () => { props.config.getUseBackgroundColor = () => false; const renderResult = await renderWithProviders( - , + , ); await renderResult.waitUntilReady(); await expect(renderResult).toMatchSvgSnapshot(); @@ -2342,6 +2389,7 @@ describe('InputPrompt', () => { const text = 'first line\n\nthird line'; mockBuffer.text = text; mockBuffer.lines = text.split('\n'); + mockBuffer.allVisualLines = text.split('\n'); mockBuffer.viewportVisualLines = text.split('\n'); mockBuffer.visualCursor = [1, 0]; // cursor on the blank line mockBuffer.visualToLogicalMap = [ @@ -2352,7 +2400,7 @@ describe('InputPrompt', () => { props.config.getUseBackgroundColor = () => false; const renderResult = await renderWithProviders( - , + , ); await renderResult.waitUntilReady(); await expect(renderResult).toMatchSvgSnapshot(); @@ -2361,11 +2409,112 @@ describe('InputPrompt', () => { }); }); + describe('scrolling large inputs', () => { + it('should correctly render scrolling down and up for large inputs', async () => { + const lines = Array.from({ length: 50 }).map((_, i) => `testline ${i}`); + + // Since we need to test how the React component tree responds to TextBuffer state changes, + // we must provide a fake TextBuffer implementation that triggers re-renders like the real one. + + const TestWrapper = () => { + const [bufferState, setBufferState] = useState({ + text: lines.join('\n'), + lines, + allVisualLines: lines, + viewportVisualLines: lines.slice(0, 10), + visualToLogicalMap: lines.map((_, i) => [i, 0]), + visualCursor: [0, 0] as [number, number], + visualScrollRow: 0, + viewportHeight: 10, + }); + + const fakeBuffer = { + ...mockBuffer, + ...bufferState, + handleInput: vi.fn().mockImplementation((key) => { + let newRow = bufferState.visualCursor[0]; + let newScroll = bufferState.visualScrollRow; + if (key.name === 'down') { + newRow = Math.min(49, newRow + 1); + if (newRow >= newScroll + 10) newScroll++; + } else if (key.name === 'up') { + newRow = Math.max(0, newRow - 1); + if (newRow < newScroll) newScroll--; + } + setBufferState({ + ...bufferState, + visualCursor: [newRow, 0], + visualScrollRow: newScroll, + viewportVisualLines: lines.slice(newScroll, newScroll + 10), + }); + return true; + }), + } as unknown as TextBuffer; + + const inputState = { + buffer: fakeBuffer, + userMessages: [], + shellModeActive: false, + showEscapePrompt: false, + copyModeEnabled: false, + inputWidth: 80, + suggestionsWidth: 80, + }; + + return ( + + + + ); + }; + + const { stdout, unmount, stdin } = await renderWithProviders( + , + { + uiActions, + }, + ); + + // Verify initial render + await waitFor(() => { + expect(stdout.lastFrame()).toContain('testline 0'); + expect(stdout.lastFrame()).not.toContain('testline 49'); + }); + + // Move cursor to bottom + for (let i = 0; i < 49; i++) { + act(() => { + stdin.write('\x1b[B'); // Arrow Down + }); + } + + await waitFor(() => { + expect(stdout.lastFrame()).toContain('testline 49'); + expect(stdout.lastFrame()).not.toContain('testline 0'); + }); + + // Move cursor back to top + for (let i = 0; i < 49; i++) { + act(() => { + stdin.write('\x1b[A'); // Arrow Up + }); + } + + await waitFor(() => { + expect(stdout.lastFrame()).toContain('testline 0'); + expect(stdout.lastFrame()).not.toContain('testline 49'); + }); + + unmount(); + }); + }); + describe('multiline rendering', () => { it('should correctly render multiline input including blank lines', async () => { const text = 'hello\n\nworld'; mockBuffer.text = text; mockBuffer.lines = text.split('\n'); + mockBuffer.allVisualLines = text.split('\n'); mockBuffer.viewportVisualLines = text.split('\n'); mockBuffer.allVisualLines = text.split('\n'); mockBuffer.visualCursor = [2, 5]; // cursor at the end of "world" @@ -2378,7 +2527,7 @@ describe('InputPrompt', () => { props.config.getUseBackgroundColor = () => false; const renderResult = await renderWithProviders( - , + , ); await renderResult.waitUntilReady(); @@ -2404,7 +2553,7 @@ describe('InputPrompt', () => { }, ])('should handle multiline paste $description', async ({ pastedText }) => { const { stdin, unmount } = await renderWithProviders( - , + , ); // Simulate a bracketed paste event from the terminal @@ -2433,7 +2582,7 @@ describe('InputPrompt', () => { vi.mocked(clipboardy.read).mockResolvedValue(largeText); const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -2456,7 +2605,7 @@ describe('InputPrompt', () => { vi.mocked(clipboardy.read).mockResolvedValue(largeText); const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -2479,7 +2628,7 @@ describe('InputPrompt', () => { vi.mocked(clipboardy.read).mockResolvedValue(smallText); const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -2504,7 +2653,7 @@ describe('InputPrompt', () => { mockBuffer.pastedContent = { [id]: largeText }; const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -2538,7 +2687,7 @@ describe('InputPrompt', () => { props.buffer.text = 'some command'; const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { await vi.runAllTimersAsync(); @@ -2574,7 +2723,7 @@ describe('InputPrompt', () => { props.buffer.text = '@file.txt'; const { stdin, unmount } = await renderWithProviders( - , + , ); // Simulate an unsafe paste of a perfect match @@ -2599,7 +2748,7 @@ describe('InputPrompt', () => { props.buffer.text = 'pasted text'; const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { await vi.runAllTimersAsync(); @@ -2648,7 +2797,7 @@ describe('InputPrompt', () => { props.buffer.text = 'pasted command'; const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { await vi.runAllTimersAsync(); @@ -2681,7 +2830,7 @@ describe('InputPrompt', () => { props.buffer.text = 'normal command'; const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { await vi.runAllTimersAsync(); @@ -2712,7 +2861,7 @@ describe('InputPrompt', () => { props.buffer.setText('text to clear'); const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -2732,7 +2881,7 @@ describe('InputPrompt', () => { vi.mocked(props.buffer.setText).mockClear(); const { stdin, unmount } = await renderWithProviders( - , + , { uiState: { history: [{ id: 1, type: 'user', text: 'test' }], @@ -2758,7 +2907,7 @@ describe('InputPrompt', () => { vi.mocked(props.buffer.setText).mockClear(); const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -2777,7 +2926,7 @@ describe('InputPrompt', () => { props.buffer.setText('some text'); const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -2800,7 +2949,7 @@ describe('InputPrompt', () => { props.shellModeActive = true; const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -2820,7 +2969,7 @@ describe('InputPrompt', () => { const { stdin, unmount } = await renderWithProviders( <> - + , ); @@ -2844,7 +2993,7 @@ describe('InputPrompt', () => { const { stdin, unmount } = await renderWithProviders( <> - + , ); @@ -2868,7 +3017,7 @@ describe('InputPrompt', () => { }); const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -2885,7 +3034,7 @@ describe('InputPrompt', () => { props.buffer.setText('some text'); const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { await vi.runAllTimersAsync(); @@ -2903,7 +3052,7 @@ describe('InputPrompt', () => { it('should not interfere with existing keyboard shortcuts', async () => { const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -2948,7 +3097,7 @@ describe('InputPrompt', () => { }); const { stdin, stdout, unmount } = await renderWithProviders( - , + , ); // Trigger reverse search with Ctrl+R @@ -2974,7 +3123,7 @@ describe('InputPrompt', () => { 'resets reverse search state on Escape ($name)', async ({ escapeSequence }) => { const { stdin, stdout, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -3022,7 +3171,7 @@ describe('InputPrompt', () => { ); const { stdin, stdout, unmount } = await renderWithProviders( - , + , ); // Enter reverse search mode with Ctrl+R @@ -3058,7 +3207,7 @@ describe('InputPrompt', () => { }); const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -3092,7 +3241,7 @@ describe('InputPrompt', () => { }); const { stdin, stdout, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -3134,7 +3283,7 @@ describe('InputPrompt', () => { ); const { stdin, stdout, unmount } = await renderWithProviders( - , + , ); // reverse search with Ctrl+R @@ -3168,7 +3317,7 @@ describe('InputPrompt', () => { props.buffer.lines = ['line 1', 'line 2', 'line 3']; const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -3187,7 +3336,7 @@ describe('InputPrompt', () => { props.buffer.lines = ['single line text']; const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -3220,7 +3369,7 @@ describe('InputPrompt', () => { ); const { stdin, stdout, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -3250,7 +3399,7 @@ describe('InputPrompt', () => { }); const { stdin, stdout, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -3299,7 +3448,7 @@ describe('InputPrompt', () => { }); const { stdin, stdout, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -3340,7 +3489,7 @@ describe('InputPrompt', () => { }); const { stdin, stdout, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -3360,7 +3509,7 @@ describe('InputPrompt', () => { props.shellModeActive = false; props.userMessages = ['oldest', 'middle', 'newest']; - await renderWithProviders(); + await renderWithProviders(); const calls = vi.mocked(useReverseSearchCompletion).mock.calls; const commandSearchCall = calls.find( @@ -3423,7 +3572,7 @@ describe('InputPrompt', () => { }); const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, uiState: {}, @@ -3471,7 +3620,7 @@ describe('InputPrompt', () => { }); const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, }, @@ -3503,7 +3652,7 @@ describe('InputPrompt', () => { }); const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, uiState: { activePtyId: 1, cleanUiDetailsVisible: false }, @@ -3538,7 +3687,7 @@ describe('InputPrompt', () => { }); const { stdin, unmount } = await renderWithProviders( - , + , { uiActions, uiState: {}, @@ -3592,7 +3741,9 @@ describe('InputPrompt', () => { async ({ relX, relY, mouseCol, mouseRow }) => { props.buffer.text = 'hello world\nsecond line'; props.buffer.lines = ['hello world', 'second line']; + props.buffer.allVisualLines = ['hello world', 'second line']; props.buffer.viewportVisualLines = ['hello world', 'second line']; + props.buffer.viewportHeight = 10; props.buffer.visualToLogicalMap = [ [0, 0], [1, 0], @@ -3601,7 +3752,7 @@ describe('InputPrompt', () => { props.buffer.visualScrollRow = 0; const { stdin, stdout, unmount } = await renderWithProviders( - , + , { mouseEventsEnabled: true, uiActions }, ); @@ -3630,12 +3781,13 @@ describe('InputPrompt', () => { it('should unfocus embedded shell on click', async () => { props.buffer.text = 'hello'; props.buffer.lines = ['hello']; + props.buffer.allVisualLines = ['hello']; props.buffer.viewportVisualLines = ['hello']; props.buffer.visualToLogicalMap = [[0, 0]]; props.isEmbeddedShellFocused = true; const { stdin, stdout, unmount } = await renderWithProviders( - , + , { mouseEventsEnabled: true, uiActions }, ); await waitFor(() => { @@ -3671,6 +3823,7 @@ describe('InputPrompt', () => { lines: currentLines, viewportVisualLines: currentLines, allVisualLines: currentLines, + viewportHeight: 10, pastedContent: { [id]: largeText }, transformationsByLine: isExpanded ? currentLines.map(() => []) @@ -3703,7 +3856,7 @@ describe('InputPrompt', () => { .mockReturnValue(isExpanded ? id : null), }; - return ; + return ; }; const { stdout, unmount, simulateClick } = await renderWithProviders( @@ -3759,6 +3912,7 @@ describe('InputPrompt', () => { lines: currentLines, viewportVisualLines: currentLines, allVisualLines: currentLines, + viewportHeight: 10, pastedContent: { [id]: largeText }, transformationsByLine: isExpanded ? currentLines.map(() => []) @@ -3795,7 +3949,7 @@ describe('InputPrompt', () => { ), }; - return ; + return ; }; const { stdout, unmount, simulateClick } = await renderWithProviders( @@ -3830,13 +3984,15 @@ describe('InputPrompt', () => { props.config.getUseBackgroundColor = () => false; props.buffer.text = 'hello world'; props.buffer.lines = ['hello world']; + props.buffer.allVisualLines = ['hello world']; props.buffer.viewportVisualLines = ['hello world']; + props.buffer.viewportHeight = 10; props.buffer.visualToLogicalMap = [[0, 0]]; props.buffer.visualCursor = [0, 11]; props.buffer.visualScrollRow = 0; const { stdin, stdout, unmount } = await renderWithProviders( - , + , { mouseEventsEnabled: true, uiActions }, ); @@ -3866,7 +4022,7 @@ describe('InputPrompt', () => { props.buffer.text = ''; const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -3886,7 +4042,7 @@ describe('InputPrompt', () => { props.buffer.text = 'some text'; const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -3906,7 +4062,7 @@ describe('InputPrompt', () => { props.buffer.text = ''; const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -3928,7 +4084,7 @@ describe('InputPrompt', () => { props.buffer.visualScrollRow = 0; const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -3945,7 +4101,7 @@ describe('InputPrompt', () => { props.buffer.text = ''; const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -3963,7 +4119,7 @@ describe('InputPrompt', () => { props.buffer.text = ' '; // Whitespace only const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -3978,7 +4134,7 @@ describe('InputPrompt', () => { props.buffer.text = ''; const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -3997,7 +4153,7 @@ describe('InputPrompt', () => { props.buffer.text = ''; const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { @@ -4016,7 +4172,7 @@ describe('InputPrompt', () => { it('should render correctly in shell mode', async () => { props.shellModeActive = true; const { stdout, unmount } = await renderWithProviders( - , + , ); await waitFor(() => expect(stdout.lastFrame()).toContain('!')); expect(stdout.lastFrame()).toMatchSnapshot(); @@ -4026,7 +4182,7 @@ describe('InputPrompt', () => { it('should render correctly when accepting edits', async () => { props.approvalMode = ApprovalMode.AUTO_EDIT; const { stdout, unmount } = await renderWithProviders( - , + , ); await waitFor(() => expect(stdout.lastFrame()).toContain('>')); expect(stdout.lastFrame()).toMatchSnapshot(); @@ -4036,7 +4192,7 @@ describe('InputPrompt', () => { it('should render correctly in yolo mode', async () => { props.approvalMode = ApprovalMode.YOLO; const { stdout, unmount } = await renderWithProviders( - , + , ); await waitFor(() => expect(stdout.lastFrame()).toContain('*')); expect(stdout.lastFrame()).toMatchSnapshot(); @@ -4046,7 +4202,7 @@ describe('InputPrompt', () => { props.isEmbeddedShellFocused = true; props.focus = false; const renderResult = await renderWithProviders( - , + , ); await renderResult.waitUntilReady(); await expect(renderResult).toMatchSvgSnapshot(); @@ -4056,7 +4212,7 @@ describe('InputPrompt', () => { it('should still allow input when shell is not focused', async () => { const { stdin, unmount } = await renderWithProviders( - , + , { shellFocus: false, }, @@ -4111,7 +4267,7 @@ describe('InputPrompt', () => { props.shellModeActive = shellMode; const { stdin, unmount } = await renderWithProviders( - , + , ); await act(async () => { stdin.write('\r'); @@ -4137,13 +4293,14 @@ describe('InputPrompt', () => { const text = 'hello'; mockBuffer.text = text; mockBuffer.lines = [text]; + mockBuffer.allVisualLines = [text]; mockBuffer.viewportVisualLines = [text]; mockBuffer.visualToLogicalMap = [[0, 0]]; mockBuffer.visualCursor = [0, 3]; // Cursor after 'hel' mockBuffer.visualScrollRow = 0; const { stdout, unmount } = await renderWithProviders( - , + , { uiActions }, ); @@ -4167,13 +4324,14 @@ describe('InputPrompt', () => { const text = '👍hello'; mockBuffer.text = text; mockBuffer.lines = [text]; + mockBuffer.allVisualLines = [text]; mockBuffer.viewportVisualLines = [text]; mockBuffer.visualToLogicalMap = [[0, 0]]; mockBuffer.visualCursor = [0, 2]; // Cursor after '👍h' (Note: '👍' is one code point but width 2) mockBuffer.visualScrollRow = 0; const { stdout, unmount } = await renderWithProviders( - , + , { uiActions }, ); @@ -4196,13 +4354,14 @@ describe('InputPrompt', () => { const text = '😀😀😀'; mockBuffer.text = text; mockBuffer.lines = [text]; + mockBuffer.allVisualLines = [text]; mockBuffer.viewportVisualLines = [text]; mockBuffer.visualToLogicalMap = [[0, 0]]; mockBuffer.visualCursor = [0, 2]; // Cursor after 2 emojis (each 1 code point, width 2) mockBuffer.visualScrollRow = 0; const { stdout, unmount } = await renderWithProviders( - , + , { uiActions }, ); @@ -4225,7 +4384,9 @@ describe('InputPrompt', () => { const lines = ['😀😀', 'hello 😀', 'world']; mockBuffer.text = lines.join('\n'); mockBuffer.lines = lines; + mockBuffer.allVisualLines = lines; mockBuffer.viewportVisualLines = lines; + mockBuffer.viewportHeight = 10; mockBuffer.visualToLogicalMap = [ [0, 0], [1, 0], @@ -4235,7 +4396,7 @@ describe('InputPrompt', () => { mockBuffer.visualScrollRow = 0; const { stdout, unmount } = await renderWithProviders( - , + , { uiActions }, ); @@ -4262,7 +4423,9 @@ describe('InputPrompt', () => { const lines = ['first line', 'second line', 'third line']; mockBuffer.text = lines.join('\n'); mockBuffer.lines = lines; + mockBuffer.allVisualLines = lines; mockBuffer.viewportVisualLines = lines; + mockBuffer.viewportHeight = 10; mockBuffer.visualToLogicalMap = [ [0, 0], [1, 0], @@ -4272,7 +4435,7 @@ describe('InputPrompt', () => { mockBuffer.visualScrollRow = 0; const { stdout, unmount } = await renderWithProviders( - , + , { uiActions }, ); @@ -4303,13 +4466,14 @@ describe('InputPrompt', () => { it('should report cursor position 0 when input is empty and placeholder is shown', async () => { mockBuffer.text = ''; mockBuffer.lines = ['']; + mockBuffer.allVisualLines = ['']; mockBuffer.viewportVisualLines = ['']; mockBuffer.visualToLogicalMap = [[0, 0]]; mockBuffer.visualCursor = [0, 0]; mockBuffer.visualScrollRow = 0; const { stdout, unmount } = await renderWithProviders( - , + , { uiActions }, ); @@ -4335,6 +4499,7 @@ describe('InputPrompt', () => { const applyVisualState = (visualLine: string, cursorCol: number): void => { mockBuffer.text = logicalLine; mockBuffer.lines = [logicalLine]; + mockBuffer.allVisualLines = [visualLine]; mockBuffer.viewportVisualLines = [visualLine]; mockBuffer.allVisualLines = [visualLine]; mockBuffer.visualToLogicalMap = [[0, 0]]; @@ -4354,7 +4519,7 @@ describe('InputPrompt', () => { applyVisualState(transformedLine, transformations[0].logEnd + 5); const { stdout, unmount } = await renderWithProviders( - , + , ); await waitFor(() => { expect(stdout.lastFrame()).toContain('[Image'); @@ -4373,7 +4538,7 @@ describe('InputPrompt', () => { applyVisualState(transformedLine, transformations[0].logStart + 1); const { stdout, unmount } = await renderWithProviders( - , + , ); await waitFor(() => { expect(stdout.lastFrame()).toContain('@/path/to/screenshots'); @@ -4414,7 +4579,7 @@ describe('InputPrompt', () => { } as unknown as TextBuffer; const { stdin, unmount } = await renderWithProviders( - , + , { uiActions }, ); @@ -4466,7 +4631,7 @@ describe('InputPrompt', () => { } const { stdin, unmount } = await renderWithProviders( - , @@ -4660,7 +4825,7 @@ describe('InputPrompt', () => { 'should move cursor to $position on $name (older history)', async ({ key, position }) => { const { stdin } = await renderWithProviders( - , + , { uiActions, }, @@ -4686,7 +4851,7 @@ describe('InputPrompt', () => { 'should move cursor to $position on $name (newer history)', async ({ key, position }) => { const { stdin } = await renderWithProviders( - , + , { uiActions, }, @@ -4716,9 +4881,12 @@ describe('InputPrompt', () => { ); it('should suppress completion after history navigation', async () => { - const { stdin } = await renderWithProviders(, { - uiActions, - }); + const { stdin } = await renderWithProviders( + , + { + uiActions, + }, + ); await act(async () => { stdin.write('\u001B[A'); // Up arrow @@ -4749,7 +4917,7 @@ describe('InputPrompt', () => { })); const { stdout, stdin, unmount } = await renderWithProviders( - , + , { uiActions }, ); @@ -4773,9 +4941,12 @@ describe('InputPrompt', () => { }); it('should continue to suppress completion after manual cursor movement', async () => { - const { stdin } = await renderWithProviders(, { - uiActions, - }); + const { stdin } = await renderWithProviders( + , + { + uiActions, + }, + ); // Navigate history (suppresses) await act(async () => { @@ -4816,9 +4987,12 @@ describe('InputPrompt', () => { }); it('should re-enable completion after typing', async () => { - const { stdin } = await renderWithProviders(, { - uiActions, - }); + const { stdin } = await renderWithProviders( + , + { + uiActions, + }, + ); // Navigate history (suppresses) await act(async () => { @@ -4853,7 +5027,7 @@ describe('InputPrompt', () => { }); const { stdin, unmount } = await renderWithProviders( - , + , { settings, uiActions: { setShortcutsHelpVisible }, @@ -4910,7 +5084,7 @@ describe('InputPrompt', () => { setupMocks?.(); const setShortcutsHelpVisible = vi.fn(); const { stdin, unmount } = await renderWithProviders( - , + , { uiState: { shortcutsHelpVisible: true }, uiActions: { setShortcutsHelpVisible }, diff --git a/packages/cli/src/ui/components/InputPrompt.tsx b/packages/cli/src/ui/components/InputPrompt.tsx index 4547c19d8a..c8d7efa1b4 100644 --- a/packages/cli/src/ui/components/InputPrompt.tsx +++ b/packages/cli/src/ui/components/InputPrompt.tsx @@ -12,6 +12,10 @@ import { SuggestionsDisplay, MAX_WIDTH } from './SuggestionsDisplay.js'; import { theme } from '../semantic-colors.js'; import { useInputHistory } from '../hooks/useInputHistory.js'; import { escapeAtSymbols } from '../hooks/atCommandProcessor.js'; +import { + ScrollableList, + type ScrollableListRef, +} from './shared/ScrollableList.js'; import { HalfLinePaddedBox } from './shared/HalfLinePaddedBox.js'; import { type TextBuffer, @@ -66,6 +70,7 @@ import { getSafeLowColorBackground } from '../themes/color-utils.js'; import { isLowColorDepth } from '../utils/terminalUtils.js'; import { useShellFocusState } from '../contexts/ShellFocusContext.js'; import { useUIState } from '../contexts/UIStateContext.js'; +import { useInputState } from '../contexts/InputContext.js'; import { appEvents, AppEvent, @@ -95,19 +100,18 @@ export function isTerminalPasteTrusted( return kittyProtocolSupported; } +export type ScrollableItem = + | { type: 'visualLine'; lineText: string; absoluteVisualIdx: number } + | { type: 'ghostLine'; ghostLine: string; index: number }; + export interface InputPromptProps { - buffer: TextBuffer; onSubmit: (value: string) => void; - userMessages: readonly string[]; onClearScreen: () => void; config: Config; slashCommands: readonly SlashCommand[]; commandContext: CommandContext; placeholder?: string; focus?: boolean; - inputWidth: number; - suggestionsWidth: number; - shellModeActive: boolean; setShellModeActive: (value: boolean) => void; approvalMode: ApprovalMode; onEscapePromptChange?: (showPrompt: boolean) => void; @@ -120,7 +124,6 @@ export interface InputPromptProps { onQueueMessage?: (message: string) => void; suggestionsPosition?: 'above' | 'below'; setBannerVisible: (visible: boolean) => void; - copyModeEnabled?: boolean; } // The input content, input container, and input suggestions list may have different widths @@ -191,18 +194,13 @@ export function tryTogglePasteExpansion(buffer: TextBuffer): boolean { } export const InputPrompt: React.FC = ({ - buffer, onSubmit, - userMessages, onClearScreen, config, slashCommands, commandContext, placeholder = ' Type your message or @path/to/file', focus = true, - inputWidth, - suggestionsWidth, - shellModeActive, setShellModeActive, approvalMode, onEscapePromptChange, @@ -215,8 +213,16 @@ export const InputPrompt: React.FC = ({ onQueueMessage, suggestionsPosition = 'below', setBannerVisible, - copyModeEnabled = false, }) => { + const inputState = useInputState(); + const { + buffer, + userMessages, + shellModeActive, + copyModeEnabled, + inputWidth, + suggestionsWidth, + } = inputState; const isHelpDismissKey = useIsHelpDismissKey(); const keyMatchers = useKeyMatchers(); const { stdout } = useStdout(); @@ -268,6 +274,7 @@ export const InputPrompt: React.FC = ({ const pasteTimeoutRef = useRef(null); const innerBoxRef = useRef(null); const hasUserNavigatedSuggestions = useRef(false); + const listRef = useRef>(null); const [reverseSearchActive, setReverseSearchActive] = useState(false); const [commandSearchActive, setCommandSearchActive] = useState(false); @@ -425,7 +432,7 @@ export const InputPrompt: React.FC = ({ slashCommands, ); if (commandToExecute?.isSafeConcurrent) { - inputHistory.handleSubmit(trimmedMessage); + handleSubmitAndClear(trimmedMessage); return; } } @@ -443,6 +450,7 @@ export const InputPrompt: React.FC = ({ streamingState, setQueueErrorMessage, slashCommands, + handleSubmitAndClear, ], ); @@ -556,7 +564,10 @@ export const InputPrompt: React.FC = ({ if (isEmbeddedShellFocused) { setEmbeddedShellFocused(false); } - const visualRow = buffer.visualScrollRow + relY; + const currentScrollTop = Math.round( + listRef.current?.getScrollState().scrollTop ?? buffer.visualScrollRow, + ); + const visualRow = currentScrollTop + relY; buffer.moveToVisualPosition(visualRow, relX); }, { isActive: focus }, @@ -570,7 +581,10 @@ export const InputPrompt: React.FC = ({ (_event, relX, relY) => { if (!isAlternateBuffer) return; - const visualLine = buffer.viewportVisualLines[relY]; + const currentScrollTop = Math.round( + listRef.current?.getScrollState().scrollTop ?? buffer.visualScrollRow, + ); + const visualLine = buffer.allVisualLines[currentScrollTop + relY]; if (!visualLine) return; // Even if we click past the end of the line, we might want to collapse an expanded paste @@ -578,10 +592,7 @@ export const InputPrompt: React.FC = ({ const logicalPos = isPastEndOfLine ? null - : buffer.getLogicalPositionFromVisual( - buffer.visualScrollRow + relY, - relX, - ); + : buffer.getLogicalPositionFromVisual(currentScrollTop + relY, relX); // Check for paste placeholder (collapsed state) if (logicalPos) { @@ -603,7 +614,9 @@ export const InputPrompt: React.FC = ({ // If we didn't click a placeholder to expand, check if we are inside or after // an expanded paste region and collapse it. - const row = buffer.visualScrollRow + relY; + const visualRow = currentScrollTop + relY; + const mapEntry = buffer.visualToLogicalMap[visualRow]; + const row = mapEntry ? mapEntry[0] : visualRow; const expandedId = buffer.getExpandedPasteAtLine(row); if (expandedId) { buffer.togglePasteExpansion( @@ -1350,10 +1363,8 @@ export const InputPrompt: React.FC = ({ priority: true, }); - const linesToRender = buffer.viewportVisualLines; const [cursorVisualRowAbsolute, cursorVisualColAbsolute] = buffer.visualCursor; - const scrollVisualRow = buffer.visualScrollRow; const getGhostTextLines = useCallback(() => { if ( @@ -1468,6 +1479,155 @@ export const InputPrompt: React.FC = ({ const { inlineGhost, additionalLines } = getGhostTextLines(); + const scrollableData = useMemo(() => { + const items: ScrollableItem[] = buffer.allVisualLines.map( + (lineText, index) => ({ + type: 'visualLine', + lineText, + absoluteVisualIdx: index, + }), + ); + + additionalLines.forEach((ghostLine, index) => { + items.push({ + type: 'ghostLine', + ghostLine, + index, + }); + }); + + return items; + }, [buffer.allVisualLines, additionalLines]); + + const renderItem = useCallback( + ({ item }: { item: ScrollableItem; index: number }) => { + if (item.type === 'ghostLine') { + const padding = Math.max(0, inputWidth - stringWidth(item.ghostLine)); + return ( + + + {item.ghostLine} + {' '.repeat(padding)} + + + ); + } + + const { lineText, absoluteVisualIdx } = item; + // console.log('renderItem called with:', lineText); + const mapEntry = buffer.visualToLogicalMap[absoluteVisualIdx]; + if (!mapEntry) return ; + + const isOnCursorLine = + focus && absoluteVisualIdx === cursorVisualRowAbsolute; + const renderedLine: React.ReactNode[] = []; + const [logicalLineIdx] = mapEntry; + const logicalLine = buffer.lines[logicalLineIdx] || ''; + const transformations = + buffer.transformationsByLine[logicalLineIdx] ?? []; + const tokens = parseInputForHighlighting( + logicalLine, + logicalLineIdx, + transformations, + ...(focus && buffer.cursor[0] === logicalLineIdx + ? [buffer.cursor[1]] + : []), + ); + const visualStartCol = + buffer.visualToTransformedMap[absoluteVisualIdx] ?? 0; + const visualEndCol = visualStartCol + cpLen(lineText); + const segments = parseSegmentsFromTokens( + tokens, + visualStartCol, + visualEndCol, + ); + let charCount = 0; + segments.forEach((seg, segIdx) => { + const segLen = cpLen(seg.text); + let display = seg.text; + if (isOnCursorLine) { + const relCol = cursorVisualColAbsolute; + const segStart = charCount; + const segEnd = segStart + segLen; + if (relCol >= segStart && relCol < segEnd) { + const charToHighlight = cpSlice( + display, + relCol - segStart, + relCol - segStart + 1, + ); + const highlighted = showCursor + ? chalk.inverse(charToHighlight) + : charToHighlight; + display = + cpSlice(display, 0, relCol - segStart) + + highlighted + + cpSlice(display, relCol - segStart + 1); + } + charCount = segEnd; + } else { + charCount += segLen; + } + const color = + seg.type === 'command' || seg.type === 'file' || seg.type === 'paste' + ? theme.text.accent + : theme.text.primary; + renderedLine.push( + + {display} + , + ); + }); + + const currentLineGhost = isOnCursorLine ? inlineGhost : ''; + if ( + isOnCursorLine && + cursorVisualColAbsolute === cpLen(lineText) && + !currentLineGhost + ) { + renderedLine.push( + + {showCursor ? chalk.inverse(' ') : ' '} + , + ); + } + const showCursorBeforeGhost = + focus && + isOnCursorLine && + cursorVisualColAbsolute === cpLen(lineText) && + currentLineGhost; + return ( + + + {renderedLine} + {showCursorBeforeGhost && (showCursor ? chalk.inverse(' ') : ' ')} + {currentLineGhost && ( + {currentLineGhost} + )} + + + ); + }, + [ + buffer.visualToLogicalMap, + buffer.lines, + buffer.transformationsByLine, + buffer.cursor, + buffer.visualToTransformedMap, + focus, + cursorVisualRowAbsolute, + cursorVisualColAbsolute, + showCursor, + inlineGhost, + inputWidth, + ], + ); + const useBackgroundColor = config.getUseBackgroundColor(); const isLowColor = isLowColorDepth(); const terminalBg = theme.background.primary || 'black'; @@ -1485,6 +1645,46 @@ export const InputPrompt: React.FC = ({ return false; }, [useBackgroundColor, isLowColor, terminalBg]); + const prevCursorRef = useRef(buffer.visualCursor); + const prevTextRef = useRef(buffer.text); + + // Effect to ensure cursor remains visible after interactions + useEffect(() => { + const cursorChanged = prevCursorRef.current !== buffer.visualCursor; + const textChanged = prevTextRef.current !== buffer.text; + + prevCursorRef.current = buffer.visualCursor; + prevTextRef.current = buffer.text; + + if (!cursorChanged && !textChanged) return; + + if (!listRef.current || !focus) return; + const { scrollTop, innerHeight } = listRef.current.getScrollState(); + if (innerHeight === 0) return; + + const cursorVisualRow = buffer.visualCursor[0]; + const actualScrollTop = Math.round(scrollTop); + + // If cursor is out of the currently visible viewport... + if ( + cursorVisualRow < actualScrollTop || + cursorVisualRow >= actualScrollTop + innerHeight + ) { + // Calculate minimal scroll to make it visible + let newScrollTop = actualScrollTop; + if (cursorVisualRow < actualScrollTop) { + newScrollTop = cursorVisualRow; + } else if (cursorVisualRow >= actualScrollTop + innerHeight) { + newScrollTop = cursorVisualRow - innerHeight + 1; + } + + listRef.current.scrollToIndex({ index: newScrollTop }); + } + }, [buffer.visualCursor, buffer.text, focus]); + + const listBackgroundColor = + useLineFallback || !useBackgroundColor ? undefined : theme.background.input; + useEffect(() => { if (onSuggestionsVisibilityChange) { onSuggestionsVisibilityChange(shouldShowSuggestions); @@ -1615,153 +1815,30 @@ export const InputPrompt: React.FC = ({ {placeholder} ) ) : ( - linesToRender - .map((lineText: string, visualIdxInRenderedSet: number) => { - const absoluteVisualIdx = - scrollVisualRow + visualIdxInRenderedSet; - const mapEntry = buffer.visualToLogicalMap[absoluteVisualIdx]; - if (!mapEntry) return null; - - const cursorVisualRow = - cursorVisualRowAbsolute - scrollVisualRow; - const isOnCursorLine = - focus && visualIdxInRenderedSet === cursorVisualRow; - - const renderedLine: React.ReactNode[] = []; - - const [logicalLineIdx] = mapEntry; - const logicalLine = buffer.lines[logicalLineIdx] || ''; - const transformations = - buffer.transformationsByLine[logicalLineIdx] ?? []; - const tokens = parseInputForHighlighting( - logicalLine, - logicalLineIdx, - transformations, - ...(focus && buffer.cursor[0] === logicalLineIdx - ? [buffer.cursor[1]] - : []), - ); - const startColInTransformed = - buffer.visualToTransformedMap[absoluteVisualIdx] ?? 0; - const visualStartCol = startColInTransformed; - const visualEndCol = visualStartCol + cpLen(lineText); - const segments = parseSegmentsFromTokens( - tokens, - visualStartCol, - visualEndCol, - ); - let charCount = 0; - segments.forEach((seg, segIdx) => { - const segLen = cpLen(seg.text); - let display = seg.text; - - if (isOnCursorLine) { - const relativeVisualColForHighlight = - cursorVisualColAbsolute; - const segStart = charCount; - const segEnd = segStart + segLen; - if ( - relativeVisualColForHighlight >= segStart && - relativeVisualColForHighlight < segEnd - ) { - const charToHighlight = cpSlice( - display, - relativeVisualColForHighlight - segStart, - relativeVisualColForHighlight - segStart + 1, - ); - const highlighted = showCursor - ? chalk.inverse(charToHighlight) - : charToHighlight; - display = - cpSlice( - display, - 0, - relativeVisualColForHighlight - segStart, - ) + - highlighted + - cpSlice( - display, - relativeVisualColForHighlight - segStart + 1, - ); - } - charCount = segEnd; - } else { - // Advance the running counter even when not on cursor line - charCount += segLen; - } - - const color = - seg.type === 'command' || - seg.type === 'file' || - seg.type === 'paste' - ? theme.text.accent - : theme.text.primary; - - renderedLine.push( - - {display} - , - ); - }); - - const currentLineGhost = isOnCursorLine ? inlineGhost : ''; - if ( - isOnCursorLine && - cursorVisualColAbsolute === cpLen(lineText) - ) { - if (!currentLineGhost) { - renderedLine.push( - - {showCursor ? chalk.inverse(' ') : ' '} - , - ); - } + + 1} + keyExtractor={(item) => + item.type === 'visualLine' + ? `line-${item.absoluteVisualIdx}` + : `ghost-${item.index}` } - - const showCursorBeforeGhost = - focus && - isOnCursorLine && - cursorVisualColAbsolute === cpLen(lineText) && - currentLineGhost; - - return ( - - - {renderedLine} - {showCursorBeforeGhost && - (showCursor ? chalk.inverse(' ') : ' ')} - {currentLineGhost && ( - - {currentLineGhost} - - )} - - - ); - }) - .concat( - additionalLines.map((ghostLine, index) => { - const padding = Math.max( - 0, - inputWidth - stringWidth(ghostLine), - ); - return ( - - {ghostLine} - {' '.repeat(padding)} - - ); - }), - ) + width="100%" + backgroundColor={listBackgroundColor} + containerHeight={Math.min( + buffer.viewportHeight, + scrollableData.length, + )} + /> + )} diff --git a/packages/cli/src/ui/components/MainContent.test.tsx b/packages/cli/src/ui/components/MainContent.test.tsx index 2bc6ee27bc..ec75573d75 100644 --- a/packages/cli/src/ui/components/MainContent.test.tsx +++ b/packages/cli/src/ui/components/MainContent.test.tsx @@ -6,7 +6,11 @@ import { renderWithProviders } from '../../test-utils/render.js'; import { createMockSettings } from '../../test-utils/settings.js'; -import { makeFakeConfig, CoreToolCallStatus } from '@google/gemini-cli-core'; +import { + makeFakeConfig, + CoreToolCallStatus, + UPDATE_TOPIC_TOOL_NAME, +} from '@google/gemini-cli-core'; import { waitFor } from '../../test-utils/async.js'; import { MainContent } from './MainContent.js'; import { getToolGroupBorderAppearance } from '../utils/borderStyles.js'; @@ -728,6 +732,158 @@ describe('MainContent', () => { unmount(); }); + describe('Narration Suppression', () => { + const settingsWithNarration = createMockSettings({ + merged: { + ui: { inlineThinkingMode: 'expanded' }, + experimental: { topicUpdateNarration: true }, + }, + }); + + it('suppresses thinking ALWAYS when narration is enabled', async () => { + mockUseSettings.mockReturnValue(settingsWithNarration); + const uiState = { + ...defaultMockUiState, + history: [ + { id: 1, type: 'user' as const, text: 'Hello' }, + { + id: 2, + type: 'thinking' as const, + thought: { + subject: 'Thinking...', + description: 'Thinking about hello', + }, + }, + { id: 3, type: 'gemini' as const, text: 'I am helping.' }, + ], + }; + + const { lastFrame, unmount } = await renderWithProviders( + , + { + uiState: uiState as Partial, + settings: settingsWithNarration, + }, + ); + + const output = lastFrame(); + expect(output).not.toContain('Thinking...'); + expect(output).toContain('I am helping.'); + unmount(); + }); + + it('suppresses text in intermediate turns (contains non-topic tools)', async () => { + mockUseSettings.mockReturnValue(settingsWithNarration); + const uiState = { + ...defaultMockUiState, + history: [ + { id: 100, type: 'user' as const, text: 'Search' }, + { + id: 101, + type: 'gemini' as const, + text: 'I will now search the files.', + }, + { + id: 102, + type: 'tool_group' as const, + tools: [ + { + callId: '1', + name: 'ls', + args: { path: '.' }, + status: CoreToolCallStatus.Success, + }, + ], + }, + ], + }; + + const { lastFrame, unmount } = await renderWithProviders( + , + { + uiState: uiState as Partial, + settings: settingsWithNarration, + }, + ); + + const output = lastFrame(); + expect(output).not.toContain('I will now search the files.'); + unmount(); + }); + + it('suppresses text that precedes a topic tool in the same turn', async () => { + mockUseSettings.mockReturnValue(settingsWithNarration); + const uiState = { + ...defaultMockUiState, + history: [ + { id: 200, type: 'user' as const, text: 'Hello' }, + { id: 201, type: 'gemini' as const, text: 'I will now help you.' }, + { + id: 202, + type: 'tool_group' as const, + tools: [ + { + callId: '1', + name: UPDATE_TOPIC_TOOL_NAME, + args: { title: 'Helping', summary: 'Helping the user' }, + status: CoreToolCallStatus.Success, + }, + ], + }, + ], + }; + + const { lastFrame, unmount } = await renderWithProviders( + , + { + uiState: uiState as Partial, + settings: settingsWithNarration, + }, + ); + + const output = lastFrame(); + expect(output).not.toContain('I will now help you.'); + expect(output).toContain('Helping'); + expect(output).toContain('Helping the user'); + unmount(); + }); + + it('shows text in the final turn if it comes AFTER the topic tool', async () => { + mockUseSettings.mockReturnValue(settingsWithNarration); + const uiState = { + ...defaultMockUiState, + history: [ + { id: 300, type: 'user' as const, text: 'Hello' }, + { + id: 301, + type: 'tool_group' as const, + tools: [ + { + callId: '1', + name: UPDATE_TOPIC_TOOL_NAME, + args: { title: 'Final Answer', summary: 'I have finished' }, + status: CoreToolCallStatus.Success, + }, + ], + }, + { id: 302, type: 'gemini' as const, text: 'Here is your answer.' }, + ], + }; + + const { lastFrame, unmount } = await renderWithProviders( + , + { + uiState: uiState as Partial, + settings: settingsWithNarration, + }, + ); + + const output = lastFrame(); + expect(output).toContain('Here is your answer.'); + unmount(); + }); + }); + it('renders multiple thinking messages sequentially correctly', async () => { mockUseSettings.mockReturnValue({ merged: { diff --git a/packages/cli/src/ui/components/MainContent.tsx b/packages/cli/src/ui/components/MainContent.tsx index 9bfa4184af..527462be28 100644 --- a/packages/cli/src/ui/components/MainContent.tsx +++ b/packages/cli/src/ui/components/MainContent.tsx @@ -91,20 +91,47 @@ export const MainContent = () => { const flags = new Array(combinedHistory.length).fill(false); if (topicUpdateNarrationEnabled) { - let toolGroupInTurn = false; + let turnIsIntermediate = false; + let hasTopicToolInTurn = false; + for (let i = combinedHistory.length - 1; i >= 0; i--) { const item = combinedHistory[i]; if (item.type === 'user' || item.type === 'user_shell') { - toolGroupInTurn = false; + turnIsIntermediate = false; + hasTopicToolInTurn = false; } else if (item.type === 'tool_group') { - toolGroupInTurn = item.tools.some((t) => isTopicTool(t.name)); + const hasTopic = item.tools.some((t) => isTopicTool(t.name)); + const hasNonTopic = item.tools.some((t) => !isTopicTool(t.name)); + if (hasTopic) { + hasTopicToolInTurn = true; + } + if (hasNonTopic) { + turnIsIntermediate = true; + } } else if ( - (item.type === 'thinking' || - item.type === 'gemini' || - item.type === 'gemini_content') && - toolGroupInTurn + item.type === 'thinking' || + item.type === 'gemini' || + item.type === 'gemini_content' ) { - flags[i] = true; + // Rule 1: Always suppress thinking when narration is enabled to avoid + // "flashing" as the model starts its response, and because the Topic + // UI provides the necessary high-level intent. + if (item.type === 'thinking') { + flags[i] = true; + continue; + } + + // Rule 2: Suppress text in intermediate turns (turns containing non-topic + // tools) to hide mechanical narration. + if (turnIsIntermediate) { + flags[i] = true; + } + + // Rule 3: Suppress text that precedes a topic tool in the same turn, + // as the topic tool "replaces" it. + if (hasTopicToolInTurn) { + flags[i] = true; + } } } } @@ -336,6 +363,10 @@ export const MainContent = () => { isAlternateBuffer, ]); + if (!uiState.isConfigInitialized) { + return null; + } + if (isAlternateBufferOrTerminalBuffer) { return scrollableList; } diff --git a/packages/cli/src/ui/components/StatsDisplay.test.tsx b/packages/cli/src/ui/components/StatsDisplay.test.tsx index b34bf60298..cd98ed400d 100644 --- a/packages/cli/src/ui/components/StatsDisplay.test.tsx +++ b/packages/cli/src/ui/components/StatsDisplay.test.tsx @@ -9,7 +9,7 @@ import { describe, it, expect, vi } from 'vitest'; import { StatsDisplay } from './StatsDisplay.js'; import * as SessionContext from '../contexts/SessionContext.js'; import { type SessionMetrics } from '../contexts/SessionContext.js'; -import { ToolCallDecision } from '@google/gemini-cli-core'; +import { ToolCallDecision, LlmRole } from '@google/gemini-cli-core'; // Mock the context to provide controlled data for testing vi.mock('../contexts/SessionContext.js', async (importOriginal) => { @@ -131,6 +131,66 @@ describe('', () => { expect(output).toMatchSnapshot(); }); + it('renders role breakdown correctly under models', async () => { + const metrics = createTestMetrics({ + models: { + 'gemini-2.5-flash': { + api: { totalRequests: 10, totalErrors: 0, totalLatencyMs: 10000 }, + tokens: { + input: 1000, + prompt: 1200, + candidates: 2000, + total: 3200, + cached: 200, + thoughts: 0, + tool: 0, + }, + roles: { + [LlmRole.MAIN]: { + totalRequests: 7, + totalErrors: 0, + totalLatencyMs: 7000, + tokens: { + input: 800, + prompt: 900, + candidates: 1500, + total: 2400, + cached: 100, + thoughts: 0, + tool: 0, + }, + }, + [LlmRole.UTILITY_TOOL]: { + totalRequests: 3, + totalErrors: 0, + totalLatencyMs: 3000, + tokens: { + input: 200, + prompt: 300, + candidates: 500, + total: 800, + cached: 100, + thoughts: 0, + tool: 0, + }, + }, + }, + }, + }, + }); + + const { lastFrame } = await renderWithMockedStats(metrics); + const output = lastFrame(); + + expect(output).toContain('gemini-2.5-flash'); + expect(output).toContain('10'); // Total requests + expect(output).toContain('↳ main'); + expect(output).toContain('7'); // main requests + expect(output).toContain('↳ utility_tool'); + expect(output).toContain('3'); // tool requests + expect(output).toMatchSnapshot(); + }); + it('renders all sections when all data is present', async () => { const metrics = createTestMetrics({ models: { diff --git a/packages/cli/src/ui/components/StatsDisplay.tsx b/packages/cli/src/ui/components/StatsDisplay.tsx index 4668a7a5a7..233e9f3ed4 100644 --- a/packages/cli/src/ui/components/StatsDisplay.tsx +++ b/packages/cli/src/ui/components/StatsDisplay.tsx @@ -12,6 +12,7 @@ import { formatDuration } from '../utils/formatters.js'; import { useSessionStats, type ModelMetrics, + type RoleMetrics, } from '../contexts/SessionContext.js'; import { getStatusColor, @@ -23,6 +24,7 @@ import { import { computeSessionStats } from '../utils/computeStats.js'; import { useSettings } from '../contexts/SettingsContext.js'; import type { QuotaStats } from '../types.js'; +import { LlmRole } from '@google/gemini-cli-core'; // A more flexible and powerful StatRow component interface StatRowProps { @@ -77,6 +79,16 @@ interface ModelUsageTableProps { models: Record; } +interface ModelRow { + name: string; + displayName: string; + requests: number | string; + cachedTokens: string; + inputTokens: string; + outputTokens: string; + isSubRow: boolean; +} + const ModelUsageTable: React.FC = ({ models }) => { const nameWidth = 28; const requestsWidth = 8; @@ -84,6 +96,46 @@ const ModelUsageTable: React.FC = ({ models }) => { const cacheReadsWidth = 14; const outputTokensWidth = 14; + const rows: ModelRow[] = []; + + Object.entries(models).forEach(([name, metrics]) => { + rows.push({ + name, + displayName: name, + requests: metrics.api.totalRequests, + cachedTokens: metrics.tokens.cached.toLocaleString(), + inputTokens: metrics.tokens.prompt.toLocaleString(), + outputTokens: metrics.tokens.candidates.toLocaleString(), + isSubRow: false, + }); + + if (metrics.roles) { + const roleEntries = Object.entries(metrics.roles).filter( + (entry): entry is [string, RoleMetrics] => + entry[1] !== undefined && entry[1].totalRequests > 0, + ); + + roleEntries.sort(([a], [b]) => { + if (a === b) return 0; + if (a === LlmRole.MAIN) return -1; + if (b === LlmRole.MAIN) return 1; + return a.localeCompare(b); + }); + + roleEntries.forEach(([role, roleMetrics]) => { + rows.push({ + name: `${name}-${role}`, + displayName: ` ↳ ${role}`, + requests: roleMetrics.totalRequests, + cachedTokens: roleMetrics.tokens.cached.toLocaleString(), + inputTokens: roleMetrics.tokens.prompt.toLocaleString(), + outputTokens: roleMetrics.tokens.candidates.toLocaleString(), + isSubRow: true, + }); + }); + } + }); + return ( @@ -131,31 +183,42 @@ const ModelUsageTable: React.FC = ({ models }) => { {/* Rows */} - {Object.entries(models).map(([name, modelMetrics]) => ( - + {rows.map((row) => ( + - - {name} + + {row.displayName} - - {modelMetrics.api.totalRequests} + + {row.requests} - - {modelMetrics.tokens.prompt.toLocaleString()} + + {row.inputTokens} - - {modelMetrics.tokens.cached.toLocaleString()} + + {row.cachedTokens} - - {modelMetrics.tokens.candidates.toLocaleString()} + + {row.outputTokens} diff --git a/packages/cli/src/ui/components/StatusRow.test.tsx b/packages/cli/src/ui/components/StatusRow.test.tsx index b80dbacabe..5f14254f4b 100644 --- a/packages/cli/src/ui/components/StatusRow.test.tsx +++ b/packages/cli/src/ui/components/StatusRow.test.tsx @@ -9,7 +9,7 @@ import { StatusRow } from './StatusRow.js'; import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest'; import { useComposerStatus } from '../hooks/useComposerStatus.js'; import { type UIState } from '../contexts/UIStateContext.js'; -import { type TextBuffer } from '../components/shared/text-buffer.js'; + import { type SessionStatsState } from '../contexts/SessionContext.js'; import { type ThoughtSummary } from '../types.js'; import { ApprovalMode } from '@google/gemini-cli-core'; @@ -29,13 +29,11 @@ describe('', () => { elapsedTime: 0, currentWittyPhrase: undefined, activeHooks: [], - buffer: { text: '' } as unknown as TextBuffer, sessionStats: { lastPromptTokenCount: 0 } as unknown as SessionStatsState, shortcutsHelpVisible: false, contextFileNames: [], showApprovalModeIndicator: ApprovalMode.DEFAULT, allowPlanMode: false, - shellModeActive: false, renderMarkdown: true, currentModel: 'gemini-3', }; diff --git a/packages/cli/src/ui/components/StatusRow.tsx b/packages/cli/src/ui/components/StatusRow.tsx index 2f059086b0..24b5a97d4e 100644 --- a/packages/cli/src/ui/components/StatusRow.tsx +++ b/packages/cli/src/ui/components/StatusRow.tsx @@ -153,6 +153,8 @@ export const StatusNode: React.FC<{ ); }; +import { useInputState } from '../contexts/InputContext.js'; + export const StatusRow: React.FC = ({ showUiDetails, isNarrow, @@ -162,6 +164,7 @@ export const StatusRow: React.FC = ({ hasPendingActionRequired, }) => { const uiState = useUIState(); + const inputState = useInputState(); const settings = useSettings(); const { isInteractiveShellWaiting, @@ -225,7 +228,7 @@ export const StatusRow: React.FC = ({ settings.merged.ui.showShortcutsHint && !hideUiDetailsForSuggestions && !hasPendingActionRequired && - uiState.buffer.text.length === 0 + inputState.buffer.text.length === 0 ) { return showUiDetails ? '? for shortcuts' : 'press tab twice for more'; } @@ -391,13 +394,14 @@ export const StatusRow: React.FC = ({ > {showUiDetails ? ( <> - {!hideUiDetailsForSuggestions && !uiState.shellModeActive && ( - - )} - {uiState.shellModeActive && ( + {!hideUiDetailsForSuggestions && + !inputState.shellModeActive && ( + + )} + {inputState.shellModeActive && ( diff --git a/packages/cli/src/ui/components/ToastDisplay.test.tsx b/packages/cli/src/ui/components/ToastDisplay.test.tsx index 9bd2847b3f..477fa47f62 100644 --- a/packages/cli/src/ui/components/ToastDisplay.test.tsx +++ b/packages/cli/src/ui/components/ToastDisplay.test.tsx @@ -9,16 +9,24 @@ import { renderWithProviders } from '../../test-utils/render.js'; import { ToastDisplay, shouldShowToast } from './ToastDisplay.js'; import { TransientMessageType } from '../../utils/events.js'; import { type UIState } from '../contexts/UIStateContext.js'; +import { type InputState } from '../contexts/InputContext.js'; import { type TextBuffer } from './shared/text-buffer.js'; import { type HistoryItem } from '../types.js'; -const renderToastDisplay = async (uiState: Partial = {}) => +const renderToastDisplay = async ( + uiState: Partial = {}, + inputState: Partial = {}, +) => renderWithProviders(, { uiState: { - buffer: { text: '' } as TextBuffer, history: [] as HistoryItem[], ...uiState, }, + inputState: { + buffer: { text: '' } as TextBuffer, + showEscapePrompt: false, + ...inputState, + }, }); describe('ToastDisplay', () => { @@ -27,86 +35,121 @@ describe('ToastDisplay', () => { }); describe('shouldShowToast', () => { - const baseState: Partial = { + const baseUIState: Partial = { ctrlCPressedOnce: false, transientMessage: null, ctrlDPressedOnce: false, - showEscapePrompt: false, - buffer: { text: '' } as TextBuffer, history: [] as HistoryItem[], queueErrorMessage: null, showIsExpandableHint: false, }; + const baseInputState: Partial = { + showEscapePrompt: false, + buffer: { text: '' } as TextBuffer, + }; + it('returns false for default state', () => { - expect(shouldShowToast(baseState as UIState)).toBe(false); + expect( + shouldShowToast(baseUIState as UIState, baseInputState as InputState), + ).toBe(false); }); it('returns true when showIsExpandableHint is true', () => { expect( - shouldShowToast({ - ...baseState, - showIsExpandableHint: true, - } as UIState), + shouldShowToast( + { + ...baseUIState, + showIsExpandableHint: true, + } as UIState, + baseInputState as InputState, + ), ).toBe(true); }); it('returns true when ctrlCPressedOnce is true', () => { expect( - shouldShowToast({ ...baseState, ctrlCPressedOnce: true } as UIState), + shouldShowToast( + { ...baseUIState, ctrlCPressedOnce: true } as UIState, + baseInputState as InputState, + ), ).toBe(true); }); it('returns true when transientMessage is present', () => { expect( - shouldShowToast({ - ...baseState, - transientMessage: { text: 'test', type: TransientMessageType.Hint }, - } as UIState), + shouldShowToast( + { + ...baseUIState, + transientMessage: { text: 'test', type: TransientMessageType.Hint }, + } as UIState, + baseInputState as InputState, + ), ).toBe(true); }); it('returns true when ctrlDPressedOnce is true', () => { expect( - shouldShowToast({ ...baseState, ctrlDPressedOnce: true } as UIState), + shouldShowToast( + { ...baseUIState, ctrlDPressedOnce: true } as UIState, + baseInputState as InputState, + ), ).toBe(true); }); it('returns true when showEscapePrompt is true and buffer is NOT empty', () => { expect( - shouldShowToast({ - ...baseState, - showEscapePrompt: true, - buffer: { text: 'some text' } as TextBuffer, - } as UIState), + shouldShowToast( + { + ...baseUIState, + } as UIState, + { + ...baseInputState, + showEscapePrompt: true, + buffer: { text: 'some text' } as TextBuffer, + } as InputState, + ), ).toBe(true); }); it('returns true when showEscapePrompt is true and history is NOT empty', () => { expect( - shouldShowToast({ - ...baseState, - showEscapePrompt: true, - history: [{ id: '1' } as unknown as HistoryItem], - } as UIState), + shouldShowToast( + { + ...baseUIState, + history: [{ id: '1' } as unknown as HistoryItem], + } as UIState, + { + ...baseInputState, + showEscapePrompt: true, + } as InputState, + ), ).toBe(true); }); it('returns false when showEscapePrompt is true but buffer and history are empty', () => { expect( - shouldShowToast({ - ...baseState, - showEscapePrompt: true, - } as UIState), + shouldShowToast( + { + ...baseUIState, + } as UIState, + { + ...baseInputState, + showEscapePrompt: true, + } as InputState, + ), ).toBe(false); }); it('returns true when queueErrorMessage is present', () => { expect( - shouldShowToast({ - ...baseState, - queueErrorMessage: 'error', - } as UIState), + shouldShowToast( + { + ...baseUIState, + queueErrorMessage: 'error', + } as UIState, + baseInputState as InputState, + ), ).toBe(true); }); }); @@ -151,18 +194,25 @@ describe('ToastDisplay', () => { }); it('renders Escape prompt when buffer is empty', async () => { - const { lastFrame } = await renderToastDisplay({ - showEscapePrompt: true, - history: [{ id: 1, type: 'user', text: 'test' }] as HistoryItem[], - }); + const { lastFrame } = await renderToastDisplay( + { + history: [{ id: 1, type: 'user', text: 'test' }] as HistoryItem[], + }, + { + showEscapePrompt: true, + }, + ); expect(lastFrame()).toMatchSnapshot(); }); it('renders Escape prompt when buffer is NOT empty', async () => { - const { lastFrame } = await renderToastDisplay({ - showEscapePrompt: true, - buffer: { text: 'some text' } as TextBuffer, - }); + const { lastFrame } = await renderToastDisplay( + {}, + { + showEscapePrompt: true, + buffer: { text: 'some text' } as TextBuffer, + }, + ); expect(lastFrame()).toMatchSnapshot(); }); diff --git a/packages/cli/src/ui/components/ToastDisplay.tsx b/packages/cli/src/ui/components/ToastDisplay.tsx index a43e062776..617c9bc7ed 100644 --- a/packages/cli/src/ui/components/ToastDisplay.tsx +++ b/packages/cli/src/ui/components/ToastDisplay.tsx @@ -8,15 +8,19 @@ import type React from 'react'; import { Text } from 'ink'; import { theme } from '../semantic-colors.js'; import { useUIState, type UIState } from '../contexts/UIStateContext.js'; +import { useInputState, type InputState } from '../contexts/InputContext.js'; import { TransientMessageType } from '../../utils/events.js'; -export function shouldShowToast(uiState: UIState): boolean { +export function shouldShowToast( + uiState: UIState, + inputState: InputState, +): boolean { return ( uiState.ctrlCPressedOnce || Boolean(uiState.transientMessage) || uiState.ctrlDPressedOnce || - (uiState.showEscapePrompt && - (uiState.buffer.text.length > 0 || uiState.history.length > 0)) || + (inputState.showEscapePrompt && + (inputState.buffer.text.length > 0 || uiState.history.length > 0)) || Boolean(uiState.queueErrorMessage) || uiState.showIsExpandableHint ); @@ -24,6 +28,7 @@ export function shouldShowToast(uiState: UIState): boolean { export const ToastDisplay: React.FC = () => { const uiState = useUIState(); + const inputState = useInputState(); if (uiState.ctrlCPressedOnce) { return ( @@ -46,8 +51,8 @@ export const ToastDisplay: React.FC = () => { ); } - if (uiState.showEscapePrompt) { - const isPromptEmpty = uiState.buffer.text.length === 0; + if (inputState.showEscapePrompt) { + const isPromptEmpty = inputState.buffer.text.length === 0; const hasHistory = uiState.history.length > 0; if (isPromptEmpty && !hasHistory) { diff --git a/packages/cli/src/ui/components/ToolConfirmationQueue.test.tsx b/packages/cli/src/ui/components/ToolConfirmationQueue.test.tsx index 451d0f4bb7..58a78d3c24 100644 --- a/packages/cli/src/ui/components/ToolConfirmationQueue.test.tsx +++ b/packages/cli/src/ui/components/ToolConfirmationQueue.test.tsx @@ -70,7 +70,7 @@ describe('ToolConfirmationQueue', () => { const confirmingTool = { tool: { callId: 'call-1', - name: 'ls', + name: 'run_shell_command', description: 'list files', status: CoreToolCallStatus.AwaitingApproval, confirmationDetails: { @@ -98,15 +98,12 @@ describe('ToolConfirmationQueue', () => { ); const output = lastFrame(); - expect(output).toContain('Action Required'); expect(output).toContain('1 of 3'); expect(output).toContain('ls'); // Tool name expect(output).toContain('list files'); // Tool description - expect(output).toContain("Allow execution of: 'ls'?"); + expect(output).toContain('Allow execution of [ls]?'); expect(output).toMatchSnapshot(); - const stickyHeaderProps = vi.mocked(StickyHeader).mock.calls[0][0]; - expect(stickyHeaderProps.borderColor).toBe(theme.status.warning); unmount(); }); @@ -183,7 +180,7 @@ describe('ToolConfirmationQueue', () => { // availableContentHeight = Math.max(9 - 6, 4) = 4 // MaxSizedBox in ToolConfirmationMessage will use 4 // It should show truncation message - await waitFor(() => expect(lastFrame()).toContain('49 hidden (Ctrl+O)')); + await waitFor(() => expect(lastFrame()).toContain('48 hidden (Ctrl+O)')); expect(lastFrame()).toMatchSnapshot(); unmount(); }); diff --git a/packages/cli/src/ui/components/ToolConfirmationQueue.tsx b/packages/cli/src/ui/components/ToolConfirmationQueue.tsx index e5294e9614..1a836662b7 100644 --- a/packages/cli/src/ui/components/ToolConfirmationQueue.tsx +++ b/packages/cli/src/ui/components/ToolConfirmationQueue.tsx @@ -9,7 +9,11 @@ import { Box, Text } from 'ink'; import { theme } from '../semantic-colors.js'; import { useConfig } from '../contexts/ConfigContext.js'; import { ToolConfirmationMessage } from './messages/ToolConfirmationMessage.js'; -import { ToolStatusIndicator, ToolInfo } from './messages/ToolShared.js'; +import { + isShellTool, + ToolStatusIndicator, + ToolInfo, +} from './messages/ToolShared.js'; import { useUIState } from '../contexts/UIStateContext.js'; import type { ConfirmingToolState } from '../hooks/useConfirmingTool.js'; import { StickyHeader } from './StickyHeader.js'; @@ -31,6 +35,16 @@ function getConfirmationHeader( return headers[details.type] ?? 'Action Required'; } +function getConfirmationLabel( + toolName: string, + details: SerializableConfirmationDetails | undefined, +): string { + if (details?.type === 'ask_user') return 'Questions'; + if (details?.type === 'exit_plan_mode') return 'Implementation'; + if (isShellTool(toolName)) return 'Shell'; + return toolName; +} + interface ToolConfirmationQueueProps { confirmingTool: ConfirmingToolState; } @@ -58,22 +72,78 @@ export const ToolConfirmationQueue: React.FC = ({ ? Math.max(uiAvailableHeight, 4) : Math.floor(terminalHeight * 0.5); + const isShell = isShellTool(tool.name); + const isEdit = tool.confirmationDetails?.type === 'edit'; + + if (isShell || isEdit) { + // Use the new simplified layout for Shell and Edit tools + const borderColor = theme.border.default; + const availableContentHeight = constrainHeight + ? Math.max(maxHeight - 3, 4) + : undefined; + + const toolLabel = getConfirmationLabel(tool.name, tool.confirmationDetails); + + return ( + + {/* Header Line */} + + + + ? {toolLabel} + {!isEdit && !!tool.description && ' '} + + {!isEdit && !!tool.description && ( + + + {tool.description} + + + )} + + {total > 1 && ( + + {index} of {total} + + )} + + + {/* Interactive Area */} + + + + + ); + } + + // Restore original logic for other tools const isRoutine = tool.confirmationDetails?.type === 'ask_user' || tool.confirmationDetails?.type === 'exit_plan_mode'; const borderColor = isRoutine ? theme.status.success : theme.status.warning; const hideToolIdentity = isRoutine; - // ToolConfirmationMessage needs to know the height available for its OWN content. - // We subtract the lines used by the Queue wrapper: - // - 2 lines for the rounded border - // - 2 lines for the Header (text + margin) - // - 2 lines for Tool Identity (text + margin) const availableContentHeight = constrainHeight ? Math.max(maxHeight - (hideToolIdentity ? 4 : 6), 4) : undefined; - const content = ( + return ( = ({ paddingX={1} flexDirection="column" > - {/* Interactive Area */} - {/* - Note: We force isFocused={true} because if this component is rendered, - it effectively acts as a modal over the shell/composer. - */} = ({ getPreferredEditor={getPreferredEditor} terminalWidth={mainAreaWidth - 4} // Adjust for parent border/padding availableTerminalHeight={availableContentHeight} + toolName={tool.name} isFocused={true} /> @@ -149,6 +215,4 @@ export const ToolConfirmationQueue: React.FC = ({ /> ); - - return content; }; diff --git a/packages/cli/src/ui/components/__snapshots__/InputPrompt.test.tsx.snap b/packages/cli/src/ui/components/__snapshots__/InputPrompt.test.tsx.snap index ab6fe9b928..59050691d2 100644 --- a/packages/cli/src/ui/components/__snapshots__/InputPrompt.test.tsx.snap +++ b/packages/cli/src/ui/components/__snapshots__/InputPrompt.test.tsx.snap @@ -93,7 +93,7 @@ exports[`InputPrompt > Highlighting and Cursor Display > single-line scenarios > exports[`InputPrompt > History Navigation and Completion Suppression > should not render suggestions during history navigation 1`] = ` "▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ > second message -▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄ + " `; @@ -120,30 +120,30 @@ exports[`InputPrompt > command search (Ctrl+R when not in shell) > expands and c exports[`InputPrompt > command search (Ctrl+R when not in shell) > renders match window and expanded view (snapshots) > command-search-render-collapsed-match 1`] = ` "▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ (r:) commit -▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄ - git commit -m "feat: add search" in src/app + + " `; exports[`InputPrompt > command search (Ctrl+R when not in shell) > renders match window and expanded view (snapshots) > command-search-render-expanded-match 1`] = ` "▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ (r:) commit -▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄ - git commit -m "feat: add search" in src/app + + " `; exports[`InputPrompt > image path transformation snapshots > should snapshot collapsed image path 1`] = ` "▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ > [Image ...reenshot2x.png] -▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄ + " `; exports[`InputPrompt > image path transformation snapshots > should snapshot expanded image path when cursor is on it 1`] = ` "▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ > @/path/to/screenshots/screenshot2x.png -▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄ + " `; @@ -168,6 +168,13 @@ exports[`InputPrompt > mouse interaction > should toggle paste expansion on doub " `; +exports[`InputPrompt > mouse interaction > should toggle paste expansion on double-click 4`] = ` +"▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ + > [Pasted Text: 10 lines] +▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄ +" +`; + exports[`InputPrompt > multiline rendering > should correctly render multiline input including blank lines 1`] = ` "──────────────────────────────────────────────────────────────────────────────────────────────────── │ > hello │ diff --git a/packages/cli/src/ui/components/__snapshots__/StatsDisplay.test.tsx.snap b/packages/cli/src/ui/components/__snapshots__/StatsDisplay.test.tsx.snap index a06587aaaf..8a58ee3440 100644 --- a/packages/cli/src/ui/components/__snapshots__/StatsDisplay.test.tsx.snap +++ b/packages/cli/src/ui/components/__snapshots__/StatsDisplay.test.tsx.snap @@ -263,3 +263,32 @@ exports[` > renders only the Performance section in its zero sta ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ " `; + +exports[` > renders role breakdown correctly under models 1`] = ` +"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮ +│ │ +│ Session Stats │ +│ │ +│ Interaction Summary │ +│ Session ID: test-session-id │ +│ Tool Calls: 0 ( ✓ 0 x 0 ) │ +│ Success Rate: 0.0% │ +│ │ +│ Performance │ +│ Wall Time: 1s │ +│ Agent Active: 10.0s │ +│ » API Time: 10.0s (100.0%) │ +│ » Tool Time: 0s (0.0%) │ +│ │ +│ │ +│ Model Usage │ +│ Use /model to view model quota information │ +│ │ +│ Model Reqs Input Tokens Cache Reads Output Tokens │ +│ ────────────────────────────────────────────────────────────────────────────────────────────── │ +│ gemini-2.5-flash 10 1,200 200 2,000 │ +│ ↳ main 7 900 100 1,500 │ +│ ↳ utility_tool 3 300 100 500 │ +╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ +" +`; diff --git a/packages/cli/src/ui/components/__snapshots__/ToolConfirmationQueue-ToolConfirmationQueue-height-allocation-and-layout-should-handle-security-warning-height-correctly.snap.svg b/packages/cli/src/ui/components/__snapshots__/ToolConfirmationQueue-ToolConfirmationQueue-height-allocation-and-layout-should-handle-security-warning-height-correctly.snap.svg index 678d4b42b3..8e57fe107e 100644 --- a/packages/cli/src/ui/components/__snapshots__/ToolConfirmationQueue-ToolConfirmationQueue-height-allocation-and-layout-should-handle-security-warning-height-correctly.snap.svg +++ b/packages/cli/src/ui/components/__snapshots__/ToolConfirmationQueue-ToolConfirmationQueue-height-allocation-and-layout-should-handle-security-warning-height-correctly.snap.svg @@ -1,130 +1,113 @@ - + - + - ╭──────────────────────────────────────────────────────────────────────────────╮ - │ - Action Required + ╭──────────────────────────────────────────────────────────────────────────────╮ + │ + ? Shell + Executes a bash command with a deceptive URL 3 of 3 - │ - │ - │ - │ - ? - run_shell_command - Executes a bash command with a deceptive URL - │ - │ - │ - │ - ... 6 hidden (Ctrl+O) ... - │ - │ - echo - "Line 37" - │ - │ - echo - "Line 38" - │ - │ - echo - "Line 39" - │ - │ - echo - "Line 40" - │ - │ - echo - "Line 41" - │ - │ - echo - "Line 42" - │ - │ - echo - "Line 43" - │ - │ - echo - "Line 44" - │ - │ - echo - "Line 45" - │ - │ - echo - "Line 46" - │ - │ - echo - "Line 47" - │ - │ - echo - "Line 48" - │ - │ - echo - "Line 49" - │ - │ - echo - "Line 50" - │ - │ - curl https://täst.com - │ - │ - │ - │ - ⚠ - Warning: - Deceptive URL(s) detected: - │ - │ - │ - │ - Original: - https://täst.com/ - │ - │ - Actual Host (Punycode): - https://xn--tst-qla.com/ - │ - │ - │ - │ - Allow execution of: 'echo'? - │ - │ - │ - │ - - ● - - - 1. - - - Allow once - - │ - │ - 2. - Allow for this session - │ - │ - 3. - No, suggest changes (esc) - │ - │ - │ - ╰──────────────────────────────────────────────────────────────────────────────╯ + │ + │ + ... 6 hidden (Ctrl+O) ... + │ + │ + │ + echo + "Line 44" + │ + │ + │ + │ + echo + "Line 45" + │ + │ + │ + │ + echo + "Line 46" + │ + │ + │ + │ + echo + "Line 47" + │ + │ + │ + │ + echo + "Line 48" + │ + │ + │ + │ + echo + "Line 49" + │ + │ + │ + │ + echo + "Line 50" + │ + │ + │ + │ + curl https://täst.com + │ + │ + │ + ╰──────────────────────────────────────────────────────────────────────────╯ + │ + │ + │ + │ + ⚠ + Warning: + Deceptive URL(s) detected: + │ + │ + │ + │ + Original: + https://täst.com/ + │ + │ + Actual Host (Punycode): + https://xn--tst-qla.com/ + │ + │ + │ + │ + Allow execution of + [echo] + ? + │ + │ + │ + │ + + ● + + + 1. + + + Allow once + + │ + │ + 2. + Allow for this session + │ + │ + 3. + No, suggest changes (esc) + │ + ╰──────────────────────────────────────────────────────────────────────────────╯ \ No newline at end of file diff --git a/packages/cli/src/ui/components/__snapshots__/ToolConfirmationQueue-ToolConfirmationQueue-height-allocation-and-layout-should-render-the-full-queue-wrapper-with-borders-and-content-for-large-edit-diffs.snap.svg b/packages/cli/src/ui/components/__snapshots__/ToolConfirmationQueue-ToolConfirmationQueue-height-allocation-and-layout-should-render-the-full-queue-wrapper-with-borders-and-content-for-large-edit-diffs.snap.svg index c39d7046bc..bbfedfab59 100644 --- a/packages/cli/src/ui/components/__snapshots__/ToolConfirmationQueue-ToolConfirmationQueue-height-allocation-and-layout-should-render-the-full-queue-wrapper-with-borders-and-content-for-large-edit-diffs.snap.svg +++ b/packages/cli/src/ui/components/__snapshots__/ToolConfirmationQueue-ToolConfirmationQueue-height-allocation-and-layout-should-render-the-full-queue-wrapper-with-borders-and-content-for-large-edit-diffs.snap.svg @@ -4,455 +4,540 @@ - ╭──────────────────────────────────────────────────────────────────────────────╮ - │ - Action Required - │ - │ - │ - │ - ? - replace - Replaces content in a file - │ - │ - │ - │ - ... 15 hidden (Ctrl+O) ... - │ - │ - - - 8 + ╭──────────────────────────────────────────────────────────────────────────────╮ + │ + ? replace + │ + │ + ╭──────────────────────────────────────────────────────────────────────────╮ + │ + │ + │ + ... 13 hidden (Ctrl+O) ... + │ + │ + │ + │ + + + 7 + + + + + + + const + + newLine7 = + + true + + ; + │ + │ + │ + │ + + + 8 + + + - + + + const + + oldLine8 = + + true + + ; + │ + │ + │ + │ - + + 8 - - const - - newLine8 = - - true - - ; - │ - │ - - - 9 + + + + + + const + + newLine8 = + + true + + ; + │ + │ + │ + │ - - + 9 - - const - - oldLine9 = - - true - - ; - │ - │ - - - 9 + + - + + + const + + oldLine9 = + + true + + ; + │ + │ + │ + │ - + + 9 - - const - - newLine9 = - - true - - ; - │ - │ - - 10 - - - - + + + + + + const + + newLine9 = + + true + + ; + │ + │ + │ + │ + + 10 - - const - - oldLine10 = - - true - - ; - │ - │ - - 10 - - - + + + - + + + const + + oldLine10 = + + true + + ; + │ + │ + │ + │ + + 10 - - const - - newLine10 = - - true - - ; - │ - │ - - 11 - - - - + + + + + + const + + newLine10 = + + true + + ; + │ + │ + │ + │ + + 11 - - const - - oldLine11 = - - true - - ; - │ - │ - - 11 - - - + + + - + + + const + + oldLine11 = + + true + + ; + │ + │ + │ + │ + + 11 - - const - - newLine11 = - - true - - ; - │ - │ - - 12 - - - - + + + + + + const + + newLine11 = + + true + + ; + │ + │ + │ + │ + + 12 - - const - - oldLine12 = - - true - - ; - │ - │ - - 12 - - - + + + - + + + const + + oldLine12 = + + true + + ; + │ + │ + │ + │ + + 12 - - const - - newLine12 = - - true - - ; - │ - │ - - 13 - - - - + + + + + + const + + newLine12 = + + true + + ; + │ + │ + │ + │ + + 13 - - const - - oldLine13 = - - true - - ; - │ - │ - - 13 - - - + + + - + + + const + + oldLine13 = + + true + + ; + │ + │ + │ + │ + + 13 - - const - - newLine13 = - - true - - ; - │ - │ - - 14 - - - - + + + + + + const + + newLine13 = + + true + + ; + │ + │ + │ + │ + + 14 - - const - - oldLine14 = - - true - - ; - │ - │ - - 14 - - - + + + - + + + const + + oldLine14 = + + true + + ; + │ + │ + │ + │ + + 14 - - const - - newLine14 = - - true - - ; - │ - │ - - 15 - - - - + + + + + + const + + newLine14 = + + true + + ; + │ + │ + │ + │ + + 15 - - const - - oldLine15 = - - true - - ; - │ - │ - - 15 - - - + + + - + + + const + + oldLine15 = + + true + + ; + │ + │ + │ + │ + + 15 - - const - - newLine15 = - - true - - ; - │ - │ - - 16 - - - - + + + + + + const + + newLine15 = + + true + + ; + │ + │ + │ + │ + + 16 - - const - - oldLine16 = - - true - - ; - │ - │ - - 16 - - - + + + - + + + const + + oldLine16 = + + true + + ; + │ + │ + │ + │ + + 16 - - const - - newLine16 = - - true - - ; - │ - │ - - 17 - - - - + + + + + + const + + newLine16 = + + true + + ; + │ + │ + │ + │ + + 17 - - const - - oldLine17 = - - true - - ; - │ - │ - - 17 - - - + + + - + + + const + + oldLine17 = + + true + + ; + │ + │ + │ + │ + + 17 - - const - - newLine17 = - - true - - ; - │ - │ - - 18 - - - - + + + + + + const + + newLine17 = + + true + + ; + │ + │ + │ + │ + + 18 - - const - - oldLine18 = - - true - - ; - │ - │ - - 18 - - - + + + - + + + const + + oldLine18 = + + true + + ; + │ + │ + │ + │ + + 18 - - const - - newLine18 = - - true - - ; - │ - │ - - 19 - - - - + + + + + + const + + newLine18 = + + true + + ; + │ + │ + │ + │ + + 19 - - const - - oldLine19 = - - true - - ; - │ - │ - - 19 - - - + + + - + + + const + + oldLine19 = + + true + + ; + │ + │ + │ + │ + + 19 - - const - - newLine19 = - - true - - ; - │ - │ - - 20 - - - - + + + + + + const + + newLine19 = + + true + + ; + │ + │ + │ + │ + + 20 - - const - - oldLine20 = - - true - - ; - │ - │ - - 20 - - - + + + - + + + const + + oldLine20 = + + true + + ; + │ + │ + │ + │ + + 20 - - const - - newLine20 = - - true - - ; - │ - │ - Apply this change? - │ - │ - │ - │ - - ● - - - 1. - - - Allow once - - │ - │ - 2. - Allow for this session - │ - │ - 3. - Modify with external editor - │ - │ - 4. - No, suggest changes (esc) - │ - │ - │ - ╰──────────────────────────────────────────────────────────────────────────────╯ + + + + + + const + + newLine20 = + + true + + ; + │ + │ + │ + ╰──────────────────────────────────────────────────────────────────────────╯ + │ + │ + Apply this change? + │ + │ + │ + │ + + ● + + + 1. + + + Allow once + + │ + │ + 2. + Allow for this session + │ + │ + 3. + Modify with external editor + │ + │ + 4. + No, suggest changes (esc) + │ + ╰──────────────────────────────────────────────────────────────────────────────╯ \ No newline at end of file diff --git a/packages/cli/src/ui/components/__snapshots__/ToolConfirmationQueue-ToolConfirmationQueue-height-allocation-and-layout-should-render-the-full-queue-wrapper-with-borders-and-content-for-large-exec-commands.snap.svg b/packages/cli/src/ui/components/__snapshots__/ToolConfirmationQueue-ToolConfirmationQueue-height-allocation-and-layout-should-render-the-full-queue-wrapper-with-borders-and-content-for-large-exec-commands.snap.svg index 508fc9d3c4..3f2d8451a8 100644 --- a/packages/cli/src/ui/components/__snapshots__/ToolConfirmationQueue-ToolConfirmationQueue-height-allocation-and-layout-should-render-the-full-queue-wrapper-with-borders-and-content-for-large-exec-commands.snap.svg +++ b/packages/cli/src/ui/components/__snapshots__/ToolConfirmationQueue-ToolConfirmationQueue-height-allocation-and-layout-should-render-the-full-queue-wrapper-with-borders-and-content-for-large-exec-commands.snap.svg @@ -4,153 +4,217 @@ - ╭──────────────────────────────────────────────────────────────────────────────╮ - │ - Action Required + ╭──────────────────────────────────────────────────────────────────────────────╮ + │ + ? Shell + Executes a bash command 2 of 3 - │ - │ - │ - │ - ? - run_shell_command - Executes a bash command - │ - │ - │ - │ - ... 24 hidden (Ctrl+O) ... - │ - │ - echo - "Line 25" - │ - │ - echo - "Line 26" - │ - │ - echo - "Line 27" - │ - │ - echo - "Line 28" - │ - │ - echo - "Line 29" - │ - │ - echo - "Line 30" - │ - │ - echo - "Line 31" - │ - │ - echo - "Line 32" - │ - │ - echo - "Line 33" - │ - │ - echo - "Line 34" - │ - │ - echo - "Line 35" - │ - │ - echo - "Line 36" - │ - │ - echo - "Line 37" - │ - │ - echo - "Line 38" - │ - │ - echo - "Line 39" - │ - │ - echo - "Line 40" - │ - │ - echo - "Line 41" - │ - │ - echo - "Line 42" - │ - │ - echo - "Line 43" - │ - │ - echo - "Line 44" - │ - │ - echo - "Line 45" - │ - │ - echo - "Line 46" - │ - │ - echo - "Line 47" - │ - │ - echo - "Line 48" - │ - │ - echo - "Line 49" - │ - │ - echo - "Line 50" - │ - │ - Allow execution of: 'echo'? - │ - │ - │ - │ - - ● - - - 1. - - - Allow once - - │ - │ - 2. - Allow for this session - │ - │ - 3. - No, suggest changes (esc) - │ - │ - │ - ╰──────────────────────────────────────────────────────────────────────────────╯ + │ + │ + ╭──────────────────────────────────────────────────────────────────────────╮ + │ + │ + │ + ... 22 hidden (Ctrl+O) ... + │ + │ + │ + │ + echo + "Line 23" + │ + │ + │ + │ + echo + "Line 24" + │ + │ + │ + │ + echo + "Line 25" + │ + │ + │ + │ + echo + "Line 26" + │ + │ + │ + │ + echo + "Line 27" + │ + │ + │ + │ + echo + "Line 28" + │ + │ + │ + │ + echo + "Line 29" + │ + │ + │ + │ + echo + "Line 30" + │ + │ + │ + │ + echo + "Line 31" + │ + │ + │ + │ + echo + "Line 32" + │ + │ + │ + │ + echo + "Line 33" + │ + │ + │ + │ + echo + "Line 34" + │ + │ + │ + │ + echo + "Line 35" + │ + │ + │ + │ + echo + "Line 36" + │ + │ + │ + │ + echo + "Line 37" + │ + │ + │ + │ + echo + "Line 38" + │ + │ + │ + │ + echo + "Line 39" + │ + │ + │ + │ + echo + "Line 40" + │ + │ + │ + │ + echo + "Line 41" + │ + │ + │ + │ + echo + "Line 42" + │ + │ + │ + │ + echo + "Line 43" + │ + │ + │ + │ + echo + "Line 44" + │ + │ + │ + │ + echo + "Line 45" + │ + │ + │ + │ + echo + "Line 46" + │ + │ + │ + │ + echo + "Line 47" + │ + │ + │ + │ + echo + "Line 48" + │ + │ + │ + │ + echo + "Line 49" + │ + │ + │ + │ + echo + "Line 50" + │ + │ + │ + ╰──────────────────────────────────────────────────────────────────────────╯ + │ + │ + Allow execution of + [echo] + ? + │ + │ + │ + │ + + ● + + + 1. + + + Allow once + + │ + │ + 2. + Allow for this session + │ + │ + 3. + No, suggest changes (esc) + │ + ╰──────────────────────────────────────────────────────────────────────────────╯ \ No newline at end of file diff --git a/packages/cli/src/ui/components/__snapshots__/ToolConfirmationQueue.test.tsx.snap b/packages/cli/src/ui/components/__snapshots__/ToolConfirmationQueue.test.tsx.snap index fdbb216cde..8d8667b51d 100644 --- a/packages/cli/src/ui/components/__snapshots__/ToolConfirmationQueue.test.tsx.snap +++ b/packages/cli/src/ui/components/__snapshots__/ToolConfirmationQueue.test.tsx.snap @@ -2,32 +2,25 @@ exports[`ToolConfirmationQueue > calculates availableContentHeight based on availableTerminalHeight from UI state 1`] = ` "╭──────────────────────────────────────────────────────────────────────────────╮ -│ Action Required │ -│ │ -│ ? replace edit file │ -│ │ -│ ... 49 hidden (Ctrl+O) ... │ -│ 50 line │ +│ ? replace │ +│ ╭──────────────────────────────────────────────────────────────────────────╮ │ +│ ╰─... 48 hidden (Ctrl+O) ...───────────────────────────────────────────────╯ │ │ Apply this change? │ │ │ │ ● 1. Allow once │ │ 2. Allow for this session │ │ 3. Modify with external editor │ │ 4. No, suggest changes (esc) │ -│ │ ╰──────────────────────────────────────────────────────────────────────────────╯ " `; exports[`ToolConfirmationQueue > does not render expansion hint when constrainHeight is false 1`] = ` "╭──────────────────────────────────────────────────────────────────────────────╮ -│ Action Required │ -│ │ -│ ? replace edit file │ -│ │ +│ ? replace │ │ ╭──────────────────────────────────────────────────────────────────────────╮ │ │ │ │ │ -│ │ No changes detected. │ │ +│ │ No changes detected. │ │ │ │ │ │ │ ╰──────────────────────────────────────────────────────────────────────────╯ │ │ Apply this change? │ @@ -36,131 +29,120 @@ exports[`ToolConfirmationQueue > does not render expansion hint when constrainHe │ 2. Allow for this session │ │ 3. Modify with external editor │ │ 4. No, suggest changes (esc) │ -│ │ ╰──────────────────────────────────────────────────────────────────────────────╯ " `; exports[`ToolConfirmationQueue > height allocation and layout > should handle security warning height correctly 1`] = ` "╭──────────────────────────────────────────────────────────────────────────────╮ -│ Action Required 3 of 3 │ -│ │ -│ ? run_shell_command Executes a bash command with a deceptive URL │ -│ │ +│ ? Shell Executes a bash command with a deceptive URL 3 of 3 │ │ ... 6 hidden (Ctrl+O) ... │ -│ echo "Line 37" │ -│ echo "Line 38" │ -│ echo "Line 39" │ -│ echo "Line 40" │ -│ echo "Line 41" │ -│ echo "Line 42" │ -│ echo "Line 43" │ -│ echo "Line 44" │ -│ echo "Line 45" │ -│ echo "Line 46" │ -│ echo "Line 47" │ -│ echo "Line 48" │ -│ echo "Line 49" │ -│ echo "Line 50" │ -│ curl https://täst.com │ +│ │ echo "Line 44" │ │ +│ │ echo "Line 45" │ │ +│ │ echo "Line 46" │ │ +│ │ echo "Line 47" │ │ +│ │ echo "Line 48" │ │ +│ │ echo "Line 49" │ │ +│ │ echo "Line 50" │ │ +│ │ curl https://täst.com │ │ +│ ╰──────────────────────────────────────────────────────────────────────────╯ │ │ │ │ ⚠ Warning: Deceptive URL(s) detected: │ │ │ │ Original: https://täst.com/ │ │ Actual Host (Punycode): https://xn--tst-qla.com/ │ │ │ -│ Allow execution of: 'echo'? │ +│ Allow execution of [echo]? │ │ │ │ ● 1. Allow once │ │ 2. Allow for this session │ │ 3. No, suggest changes (esc) │ -│ │ ╰──────────────────────────────────────────────────────────────────────────────╯ " `; exports[`ToolConfirmationQueue > height allocation and layout > should render the full queue wrapper with borders and content for large edit diffs 1`] = ` "╭──────────────────────────────────────────────────────────────────────────────╮ -│ Action Required │ -│ │ -│ ? replace Replaces content in a file │ -│ │ -│ ... 15 hidden (Ctrl+O) ... │ -│ 8 + const newLine8 = true; │ -│ 9 - const oldLine9 = true; │ -│ 9 + const newLine9 = true; │ -│ 10 - const oldLine10 = true; │ -│ 10 + const newLine10 = true; │ -│ 11 - const oldLine11 = true; │ -│ 11 + const newLine11 = true; │ -│ 12 - const oldLine12 = true; │ -│ 12 + const newLine12 = true; │ -│ 13 - const oldLine13 = true; │ -│ 13 + const newLine13 = true; │ -│ 14 - const oldLine14 = true; │ -│ 14 + const newLine14 = true; │ -│ 15 - const oldLine15 = true; │ -│ 15 + const newLine15 = true; │ -│ 16 - const oldLine16 = true; │ -│ 16 + const newLine16 = true; │ -│ 17 - const oldLine17 = true; │ -│ 17 + const newLine17 = true; │ -│ 18 - const oldLine18 = true; │ -│ 18 + const newLine18 = true; │ -│ 19 - const oldLine19 = true; │ -│ 19 + const newLine19 = true; │ -│ 20 - const oldLine20 = true; │ -│ 20 + const newLine20 = true; │ +│ ? replace │ +│ ╭──────────────────────────────────────────────────────────────────────────╮ │ +│ │ ... 13 hidden (Ctrl+O) ... │ │ +│ │ 7 + const newLine7 = true; │ │ +│ │ 8 - const oldLine8 = true; │ │ +│ │ 8 + const newLine8 = true; │ │ +│ │ 9 - const oldLine9 = true; │ │ +│ │ 9 + const newLine9 = true; │ │ +│ │ 10 - const oldLine10 = true; │ │ +│ │ 10 + const newLine10 = true; │ │ +│ │ 11 - const oldLine11 = true; │ │ +│ │ 11 + const newLine11 = true; │ │ +│ │ 12 - const oldLine12 = true; │ │ +│ │ 12 + const newLine12 = true; │ │ +│ │ 13 - const oldLine13 = true; │ │ +│ │ 13 + const newLine13 = true; │ │ +│ │ 14 - const oldLine14 = true; │ │ +│ │ 14 + const newLine14 = true; │ │ +│ │ 15 - const oldLine15 = true; │ │ +│ │ 15 + const newLine15 = true; │ │ +│ │ 16 - const oldLine16 = true; │ │ +│ │ 16 + const newLine16 = true; │ │ +│ │ 17 - const oldLine17 = true; │ │ +│ │ 17 + const newLine17 = true; │ │ +│ │ 18 - const oldLine18 = true; │ │ +│ │ 18 + const newLine18 = true; │ │ +│ │ 19 - const oldLine19 = true; │ │ +│ │ 19 + const newLine19 = true; │ │ +│ │ 20 - const oldLine20 = true; │ │ +│ │ 20 + const newLine20 = true; │ │ +│ ╰──────────────────────────────────────────────────────────────────────────╯ │ │ Apply this change? │ │ │ │ ● 1. Allow once │ │ 2. Allow for this session │ │ 3. Modify with external editor │ │ 4. No, suggest changes (esc) │ -│ │ ╰──────────────────────────────────────────────────────────────────────────────╯ " `; exports[`ToolConfirmationQueue > height allocation and layout > should render the full queue wrapper with borders and content for large exec commands 1`] = ` "╭──────────────────────────────────────────────────────────────────────────────╮ -│ Action Required 2 of 3 │ -│ │ -│ ? run_shell_command Executes a bash command │ -│ │ -│ ... 24 hidden (Ctrl+O) ... │ -│ echo "Line 25" │ -│ echo "Line 26" │ -│ echo "Line 27" │ -│ echo "Line 28" │ -│ echo "Line 29" │ -│ echo "Line 30" │ -│ echo "Line 31" │ -│ echo "Line 32" │ -│ echo "Line 33" │ -│ echo "Line 34" │ -│ echo "Line 35" │ -│ echo "Line 36" │ -│ echo "Line 37" │ -│ echo "Line 38" │ -│ echo "Line 39" │ -│ echo "Line 40" │ -│ echo "Line 41" │ -│ echo "Line 42" │ -│ echo "Line 43" │ -│ echo "Line 44" │ -│ echo "Line 45" │ -│ echo "Line 46" │ -│ echo "Line 47" │ -│ echo "Line 48" │ -│ echo "Line 49" │ -│ echo "Line 50" │ -│ Allow execution of: 'echo'? │ +│ ? Shell Executes a bash command 2 of 3 │ +│ ╭──────────────────────────────────────────────────────────────────────────╮ │ +│ │ ... 22 hidden (Ctrl+O) ... │ │ +│ │ echo "Line 23" │ │ +│ │ echo "Line 24" │ │ +│ │ echo "Line 25" │ │ +│ │ echo "Line 26" │ │ +│ │ echo "Line 27" │ │ +│ │ echo "Line 28" │ │ +│ │ echo "Line 29" │ │ +│ │ echo "Line 30" │ │ +│ │ echo "Line 31" │ │ +│ │ echo "Line 32" │ │ +│ │ echo "Line 33" │ │ +│ │ echo "Line 34" │ │ +│ │ echo "Line 35" │ │ +│ │ echo "Line 36" │ │ +│ │ echo "Line 37" │ │ +│ │ echo "Line 38" │ │ +│ │ echo "Line 39" │ │ +│ │ echo "Line 40" │ │ +│ │ echo "Line 41" │ │ +│ │ echo "Line 42" │ │ +│ │ echo "Line 43" │ │ +│ │ echo "Line 44" │ │ +│ │ echo "Line 45" │ │ +│ │ echo "Line 46" │ │ +│ │ echo "Line 47" │ │ +│ │ echo "Line 48" │ │ +│ │ echo "Line 49" │ │ +│ │ echo "Line 50" │ │ +│ ╰──────────────────────────────────────────────────────────────────────────╯ │ +│ Allow execution of [echo]? │ │ │ │ ● 1. Allow once │ │ 2. Allow for this session │ │ 3. No, suggest changes (esc) │ -│ │ ╰──────────────────────────────────────────────────────────────────────────────╯ " `; @@ -216,17 +198,15 @@ exports[`ToolConfirmationQueue > renders ExitPlanMode tool confirmation with Suc exports[`ToolConfirmationQueue > renders the confirming tool with progress indicator 1`] = ` "╭──────────────────────────────────────────────────────────────────────────────╮ -│ Action Required 1 of 3 │ -│ │ -│ ? ls list files │ -│ │ -│ ls │ -│ Allow execution of: 'ls'? │ +│ ? Shell list files 1 of 3 │ +│ ╭──────────────────────────────────────────────────────────────────────────╮ │ +│ │ ls │ │ +│ ╰──────────────────────────────────────────────────────────────────────────╯ │ +│ Allow execution of [ls]? │ │ │ │ ● 1. Allow once │ │ 2. Allow for this session │ │ 3. No, suggest changes (esc) │ -│ │ ╰──────────────────────────────────────────────────────────────────────────────╯ " `; diff --git a/packages/cli/src/ui/components/messages/DiffRenderer.test.tsx b/packages/cli/src/ui/components/messages/DiffRenderer.test.tsx index 5f75d6e009..aa5a95fd8d 100644 --- a/packages/cli/src/ui/components/messages/DiffRenderer.test.tsx +++ b/packages/cli/src/ui/components/messages/DiffRenderer.test.tsx @@ -48,15 +48,18 @@ index 0000000..e69de29 }, ); await waitFor(() => - expect(mockColorizeCode).toHaveBeenCalledWith({ - code: 'print("hello world")', - language: 'python', - availableHeight: undefined, - maxWidth: 80, - theme: undefined, - settings: expect.anything(), - disableColor: false, - }), + expect(mockColorizeCode).toHaveBeenCalledWith( + expect.objectContaining({ + code: 'print("hello world")', + language: 'python', + availableHeight: undefined, + maxWidth: 80, + theme: undefined, + settings: expect.anything(), + disableColor: false, + paddingX: 0, + }), + ), ); }); @@ -83,15 +86,18 @@ index 0000000..e69de29 }, ); await waitFor(() => - expect(mockColorizeCode).toHaveBeenCalledWith({ - code: 'some content', - language: null, - availableHeight: undefined, - maxWidth: 80, - theme: undefined, - settings: expect.anything(), - disableColor: false, - }), + expect(mockColorizeCode).toHaveBeenCalledWith( + expect.objectContaining({ + code: 'some content', + language: null, + availableHeight: undefined, + maxWidth: 80, + theme: undefined, + settings: expect.anything(), + disableColor: false, + paddingX: 0, + }), + ), ); }); @@ -114,15 +120,18 @@ index 0000000..e69de29 }, ); await waitFor(() => - expect(mockColorizeCode).toHaveBeenCalledWith({ - code: 'some text content', - language: null, - availableHeight: undefined, - maxWidth: 80, - theme: undefined, - settings: expect.anything(), - disableColor: false, - }), + expect(mockColorizeCode).toHaveBeenCalledWith( + expect.objectContaining({ + code: 'some text content', + language: null, + availableHeight: undefined, + maxWidth: 80, + theme: undefined, + settings: expect.anything(), + disableColor: false, + paddingX: 0, + }), + ), ); }); diff --git a/packages/cli/src/ui/components/messages/DiffRenderer.tsx b/packages/cli/src/ui/components/messages/DiffRenderer.tsx index ddee2e55df..3eaadf8365 100644 --- a/packages/cli/src/ui/components/messages/DiffRenderer.tsx +++ b/packages/cli/src/ui/components/messages/DiffRenderer.tsx @@ -32,6 +32,7 @@ export function parseDiffWithLineNumbers(diffContent: string): DiffLine[] { for (const line of lines) { const hunkMatch = line.match(hunkHeaderRegex); if (hunkMatch) { + currentOldLine = parseInt(hunkMatch[1], 10); currentOldLine = parseInt(hunkMatch[1], 10); currentNewLine = parseInt(hunkMatch[2], 10); inHunk = true; @@ -89,6 +90,7 @@ interface DiffRendererProps { terminalWidth: number; theme?: Theme; disableColor?: boolean; + paddingX?: number; } const DEFAULT_TAB_WIDTH = 4; // Spaces per tab for normalization @@ -101,6 +103,7 @@ export const DiffRenderer: React.FC = ({ terminalWidth, theme, disableColor = false, + paddingX = 0, }) => { const settings = useSettings(); @@ -122,11 +125,7 @@ export const DiffRenderer: React.FC = ({ if (parsedLines.length === 0) { return ( - + No changes detected. ); @@ -162,12 +161,14 @@ export const DiffRenderer: React.FC = ({ theme, settings, disableColor, + paddingX, }); } else { const key = filename ? `diff-box-${filename}` : undefined; return ( = ({ settings, tabWidth, disableColor, + paddingX, ]); return renderedOutput; @@ -239,12 +241,7 @@ export const renderDiffLines = ({ if (displayableLines.length === 0) { return [ - + No changes detected. , ]; diff --git a/packages/cli/src/ui/components/messages/RedirectionConfirmation.test.tsx b/packages/cli/src/ui/components/messages/RedirectionConfirmation.test.tsx index 95f0cffb69..2b09401e55 100644 --- a/packages/cli/src/ui/components/messages/RedirectionConfirmation.test.tsx +++ b/packages/cli/src/ui/components/messages/RedirectionConfirmation.test.tsx @@ -42,6 +42,7 @@ describe('ToolConfirmationMessage Redirection', () => { getPreferredEditor={vi.fn()} availableTerminalHeight={30} terminalWidth={100} + toolName="shell" />, ); diff --git a/packages/cli/src/ui/components/messages/ToolConfirmationMessage.test.tsx b/packages/cli/src/ui/components/messages/ToolConfirmationMessage.test.tsx index f04b47a63e..3a3a4df557 100644 --- a/packages/cli/src/ui/components/messages/ToolConfirmationMessage.test.tsx +++ b/packages/cli/src/ui/components/messages/ToolConfirmationMessage.test.tsx @@ -62,6 +62,7 @@ describe('ToolConfirmationMessage', () => { getPreferredEditor={vi.fn()} availableTerminalHeight={30} terminalWidth={80} + toolName="shell" />, ); @@ -88,6 +89,7 @@ describe('ToolConfirmationMessage', () => { getPreferredEditor={vi.fn()} availableTerminalHeight={30} terminalWidth={80} + toolName="shell" />, ); @@ -111,6 +113,7 @@ describe('ToolConfirmationMessage', () => { getPreferredEditor={vi.fn()} availableTerminalHeight={30} terminalWidth={80} + toolName="shell" />, ); @@ -140,6 +143,7 @@ describe('ToolConfirmationMessage', () => { getPreferredEditor={vi.fn()} availableTerminalHeight={30} terminalWidth={80} + toolName="shell" />, ); @@ -169,6 +173,7 @@ describe('ToolConfirmationMessage', () => { getPreferredEditor={vi.fn()} availableTerminalHeight={30} terminalWidth={80} + toolName="shell" />, ); @@ -197,6 +202,7 @@ describe('ToolConfirmationMessage', () => { getPreferredEditor={vi.fn()} availableTerminalHeight={30} terminalWidth={80} + toolName="shell" />, ); @@ -225,6 +231,7 @@ describe('ToolConfirmationMessage', () => { getPreferredEditor={vi.fn()} availableTerminalHeight={30} terminalWidth={80} + toolName="shell" />, ); @@ -253,6 +260,7 @@ describe('ToolConfirmationMessage', () => { getPreferredEditor={vi.fn()} availableTerminalHeight={30} terminalWidth={80} + toolName="shell" />, ); await result.waitUntilReady(); @@ -338,6 +346,7 @@ describe('ToolConfirmationMessage', () => { getPreferredEditor={vi.fn()} availableTerminalHeight={30} terminalWidth={80} + toolName="shell" />, ); @@ -361,6 +370,7 @@ describe('ToolConfirmationMessage', () => { getPreferredEditor={vi.fn()} availableTerminalHeight={30} terminalWidth={80} + toolName="shell" />, ); @@ -396,6 +406,7 @@ describe('ToolConfirmationMessage', () => { getPreferredEditor={vi.fn()} availableTerminalHeight={30} terminalWidth={80} + toolName="shell" />, { settings: createMockSettings({ @@ -423,6 +434,7 @@ describe('ToolConfirmationMessage', () => { getPreferredEditor={vi.fn()} availableTerminalHeight={30} terminalWidth={80} + toolName="shell" />, { settings: createMockSettings({ @@ -474,6 +486,7 @@ describe('ToolConfirmationMessage', () => { getPreferredEditor={vi.fn()} availableTerminalHeight={30} terminalWidth={80} + toolName="shell" />, ); @@ -505,6 +518,7 @@ describe('ToolConfirmationMessage', () => { getPreferredEditor={vi.fn()} availableTerminalHeight={30} terminalWidth={80} + toolName="shell" />, ); @@ -536,6 +550,7 @@ describe('ToolConfirmationMessage', () => { getPreferredEditor={vi.fn()} availableTerminalHeight={30} terminalWidth={80} + toolName="shell" />, ); @@ -562,6 +577,7 @@ describe('ToolConfirmationMessage', () => { getPreferredEditor={vi.fn()} availableTerminalHeight={30} terminalWidth={80} + toolName="shell" />, ); @@ -607,6 +623,7 @@ describe('ToolConfirmationMessage', () => { getPreferredEditor={vi.fn()} availableTerminalHeight={30} terminalWidth={80} + toolName="shell" />, ); @@ -638,6 +655,7 @@ describe('ToolConfirmationMessage', () => { getPreferredEditor={vi.fn()} availableTerminalHeight={30} terminalWidth={80} + toolName="shell" />, ); @@ -672,13 +690,14 @@ describe('ToolConfirmationMessage', () => { getPreferredEditor={vi.fn()} availableTerminalHeight={40} terminalWidth={80} + toolName="shell" />, ); await waitUntilReady(); const outputLines = lastFrame().split('\n'); - // Should use the entire terminal height minus 1 line for the "Press Ctrl+O to show more lines" hint - expect(outputLines.length).toBe(39); + // Should use the entire terminal height + expect(outputLines.length).toBe(40); await expect({ lastFrame, generateSvg }).toMatchSvgSnapshot(); unmount(); @@ -712,13 +731,14 @@ describe('ToolConfirmationMessage', () => { getPreferredEditor={vi.fn()} availableTerminalHeight={40} terminalWidth={80} + toolName="shell" />, ); await waitUntilReady(); const outputLines = lastFrame().split('\n'); - // Should use the entire terminal height minus 1 line for the "Press Ctrl+O to show more lines" hint - expect(outputLines.length).toBe(39); + // Should use the entire terminal height + expect(outputLines.length).toBe(40); await expect({ lastFrame, generateSvg }).toMatchSvgSnapshot(); unmount(); @@ -761,6 +781,7 @@ describe('ToolConfirmationMessage', () => { getPreferredEditor={vi.fn()} availableTerminalHeight={30} terminalWidth={80} + toolName="shell" />, ); diff --git a/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx b/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx index fa565bc103..b23282959e 100644 --- a/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx +++ b/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx @@ -24,13 +24,14 @@ import { RadioButtonSelect, type RadioSelectItem, } from '../shared/RadioButtonSelect.js'; -import { MaxSizedBox, MINIMUM_MAX_HEIGHT } from '../shared/MaxSizedBox.js'; +import { MaxSizedBox } from '../shared/MaxSizedBox.js'; import { sanitizeForDisplay, stripUnsafeCharacters, } from '../../utils/textUtils.js'; import { useKeypress } from '../../hooks/useKeypress.js'; import { theme } from '../../semantic-colors.js'; +import { themeManager } from '../../themes/theme-manager.js'; import { useSettings } from '../../contexts/SettingsContext.js'; import { Command } from '../../key/keyMatchers.js'; import { formatCommand } from '../../key/keybindingUtils.js'; @@ -44,6 +45,7 @@ import { type DeceptiveUrlDetails, } from '../../utils/urlSecurityUtils.js'; import { useKeyMatchers } from '../../hooks/useKeyMatchers.js'; +import { isShellTool } from './ToolShared.js'; export interface ToolConfirmationMessageProps { callId: string; @@ -53,13 +55,9 @@ export interface ToolConfirmationMessageProps { isFocused?: boolean; availableTerminalHeight?: number; terminalWidth: number; + toolName: string; } -const REDIRECTION_WARNING_NOTE_LABEL = 'Note: '; -const REDIRECTION_WARNING_NOTE_TEXT = - 'Command contains redirection which can be undesirable.'; -const REDIRECTION_WARNING_TIP_LABEL = 'Tip: '; // Padded to align with "Note: " - export const ToolConfirmationMessage: React.FC< ToolConfirmationMessageProps > = ({ @@ -70,6 +68,7 @@ export const ToolConfirmationMessage: React.FC< isFocused = true, availableTerminalHeight, terminalWidth, + toolName, }) => { const keyMatchers = useKeyMatchers(); const { confirm, isDiffingEnabled } = useToolActions(); @@ -152,6 +151,7 @@ export const ToolConfirmationMessage: React.FC< }, []); const settings = useSettings(); + const activeTheme = themeManager.getActiveTheme(); const allowPermanentApproval = settings.merged.security.enablePermanentToolApproval && !config.getDisableAlwaysAllow(); @@ -254,8 +254,6 @@ export const ToolConfirmationMessage: React.FC< return true; } if (keyMatchers[Command.QUIT](key)) { - // Return false to let ctrl-C bubble up to AppContainer for exit flow. - // AppContainer will call cancelOngoingRequest which will cancel the tool. return false; } return false; @@ -398,7 +396,6 @@ export const ToolConfirmationMessage: React.FC< key: 'No, suggest changes (esc)', }); } else if (confirmationDetails.type === 'mcp') { - // mcp tool confirmation options.push({ label: 'Allow once', value: ToolConfirmationOutcome.ProceedOnce, @@ -449,40 +446,66 @@ export const ToolConfirmationMessage: React.FC< // Calculate the vertical space (in lines) consumed by UI elements // surrounding the main body content. - const PADDING_OUTER_Y = 1; // Main container has `paddingBottom={1}`. - const HEIGHT_QUESTION = 1; // The question text is one line. - const MARGIN_QUESTION_BOTTOM = 1; // Margin on the question container. - const SECURITY_WARNING_BOTTOM_MARGIN = 1; // Margin on the securityWarnings container. - const SHOW_MORE_LINES_HEIGHT = 1; // The "Press Ctrl+O to show more lines" hint. + const PADDING_OUTER_Y = 0; + const HEIGHT_QUESTION = 1; + const MARGIN_QUESTION_TOP = 0; + const MARGIN_QUESTION_BOTTOM = 1; + const SECURITY_WARNING_BOTTOM_MARGIN = 1; + const SHOW_MORE_LINES_HEIGHT = 1; const optionsCount = getOptions().length; - // The measured height includes the margin inside WarningMessage (1 line). - // We also add 1 line for the marginBottom on the securityWarnings container. const securityWarningsHeight = deceptiveUrlWarningText ? measuredSecurityWarningsHeight + SECURITY_WARNING_BOTTOM_MARGIN : 0; + let extraInfoLines = 0; + if (confirmationDetails.type === 'sandbox_expansion') { + const { additionalPermissions } = confirmationDetails; + if (additionalPermissions?.network) extraInfoLines++; + extraInfoLines += additionalPermissions?.fileSystem?.read?.length || 0; + extraInfoLines += additionalPermissions?.fileSystem?.write?.length || 0; + } else if (confirmationDetails.type === 'exec') { + const executionProps = confirmationDetails; + const commandsToDisplay = + executionProps.commands && executionProps.commands.length > 0 + ? executionProps.commands + : [executionProps.command]; + const containsRedirection = commandsToDisplay.some((cmd) => + hasRedirection(cmd), + ); + const isAutoEdit = + config.getApprovalMode() === ApprovalMode.YOLO || + config.getApprovalMode() === ApprovalMode.AUTO_EDIT; + if (containsRedirection && !isAutoEdit) { + extraInfoLines = 1; // Warning line + } + } + const surroundingElementsHeight = PADDING_OUTER_Y + HEIGHT_QUESTION + + MARGIN_QUESTION_TOP + MARGIN_QUESTION_BOTTOM + SHOW_MORE_LINES_HEIGHT + optionsCount + - securityWarningsHeight; + securityWarningsHeight + + extraInfoLines; - return Math.max(availableTerminalHeight - surroundingElementsHeight, 1); + return Math.max(availableTerminalHeight - surroundingElementsHeight, 2); }, [ availableTerminalHeight, handlesOwnUI, getOptions, measuredSecurityWarningsHeight, deceptiveUrlWarningText, + confirmationDetails, + config, ]); const { question, bodyContent, options, securityWarnings, initialIndex } = useMemo<{ - question: string; + question: React.ReactNode; bodyContent: React.ReactNode; options: Array>; securityWarnings: React.ReactNode; @@ -490,7 +513,7 @@ export const ToolConfirmationMessage: React.FC< }>(() => { let bodyContent: React.ReactNode | null = null; let securityWarnings: React.ReactNode | null = null; - let question = ''; + let question: React.ReactNode = ''; const options = getOptions(); let initialIndex = 0; @@ -519,6 +542,8 @@ export const ToolConfirmationMessage: React.FC< securityWarnings = ; } + const bodyHeight = availableBodyContentHeight(); + if (confirmationDetails.type === 'ask_user') { bodyContent = ( ); return { @@ -563,7 +588,7 @@ export const ToolConfirmationMessage: React.FC< handleConfirm(ToolConfirmationOutcome.Cancel); }} width={terminalWidth} - availableHeight={availableBodyContentHeight()} + availableHeight={bodyHeight} /> ); return { @@ -578,85 +603,109 @@ export const ToolConfirmationMessage: React.FC< if (confirmationDetails.type === 'edit') { if (!confirmationDetails.isModifying) { question = `Apply this change?`; - } - } else if (confirmationDetails.type === 'sandbox_expansion') { - question = `Allow sandbox expansion for: '${sanitizeForDisplay(confirmationDetails.rootCommand)}'?`; - } else if (confirmationDetails.type === 'exec') { - const executionProps = confirmationDetails; - - if (executionProps.commands && executionProps.commands.length > 1) { - question = `Allow execution of ${executionProps.commands.length} commands?`; - } else { - question = `Allow execution of: '${sanitizeForDisplay(executionProps.rootCommand)}'?`; - } - } else if (confirmationDetails.type === 'info') { - question = `Do you want to proceed?`; - } else if (confirmationDetails.type === 'mcp') { - // mcp tool confirmation - const mcpProps = confirmationDetails; - question = `Allow execution of MCP tool "${sanitizeForDisplay(mcpProps.toolName)}" from server "${sanitizeForDisplay(mcpProps.serverName)}"?`; - } - - if (confirmationDetails.type === 'edit') { - if (!confirmationDetails.isModifying) { bodyContent = ( - + <> + + + + ); } } else if (confirmationDetails.type === 'sandbox_expansion') { - const { additionalPermissions } = confirmationDetails; + const { additionalPermissions, command, rootCommand } = + confirmationDetails; const readPaths = additionalPermissions?.fileSystem?.read || []; const writePaths = additionalPermissions?.fileSystem?.write || []; const network = additionalPermissions?.network; + const isShell = isShellTool(toolName); + + const rootCmds = rootCommand + .split(',') + .map((c) => c.trim().split(/\s+/)[0]) + .filter((c) => c && !c.startsWith('redirection')); + const commandNames = Array.from(new Set(rootCmds)).join(', '); + question = ''; bodyContent = ( - - - The agent is requesting additional sandbox permissions to execute - this command: - - - - {sanitizeForDisplay(confirmationDetails.command)} - + <> + + {colorizeCode({ + code: command.trim(), + language: 'bash', + maxWidth: Math.max(terminalWidth, 1) - 6, + settings, + theme: activeTheme, + hideLineNumbers: true, + availableHeight: + bodyHeight !== undefined + ? Math.max(bodyHeight - 2, 2) + : undefined, + })} - {network && ( - - • Network Access - - )} - {readPaths.length > 0 && ( - - • Read Access: - {readPaths.map((p, i) => ( - - {' '} - {sanitizeForDisplay(p)} - - ))} - - )} - {writePaths.length > 0 && ( - - • Write Access: - {writePaths.map((p, i) => ( - - {' '} - {sanitizeForDisplay(p)} - - ))} - - )} - + + + To run{' '} + + [{sanitizeForDisplay(commandNames)}] + + , allow access to the following? + + {network && ( + + + • Network: + {' '} + All Urls + + )} + {writePaths.length > 0 && ( + + + • Write: + {' '} + {writePaths.map((p) => sanitizeForDisplay(p)).join(', ')} + + )} + {readPaths.length > 0 && ( + + + • Read: + {' '} + {readPaths.map((p) => sanitizeForDisplay(p)).join(', ')} + + )} + + ); } else if (confirmationDetails.type === 'exec') { const executionProps = confirmationDetails; - + const isShell = isShellTool(toolName); const commandsToDisplay = executionProps.commands && executionProps.commands.length > 1 ? executionProps.commands @@ -664,80 +713,96 @@ export const ToolConfirmationMessage: React.FC< const containsRedirection = commandsToDisplay.some((cmd) => hasRedirection(cmd), ); + const isAutoEdit = + config.getApprovalMode() === ApprovalMode.YOLO || + config.getApprovalMode() === ApprovalMode.AUTO_EDIT; - let bodyContentHeight = availableBodyContentHeight(); let warnings: React.ReactNode = null; - - const isAutoEdit = config.getApprovalMode() === ApprovalMode.AUTO_EDIT; if (containsRedirection && !isAutoEdit) { - // Calculate lines needed for Note and Tip - const safeWidth = Math.max(terminalWidth, 1); - const noteLength = - REDIRECTION_WARNING_NOTE_LABEL.length + - REDIRECTION_WARNING_NOTE_TEXT.length; - const tipText = `Toggle auto-edit (${formatCommand(Command.CYCLE_APPROVAL_MODE)}) to allow redirection in the future.`; - const tipLength = - REDIRECTION_WARNING_TIP_LABEL.length + tipText.length; - - const noteLines = Math.ceil(noteLength / safeWidth); - const tipLines = Math.ceil(tipLength / safeWidth); - const spacerLines = 1; - const warningHeight = noteLines + tipLines + spacerLines; - - if (bodyContentHeight !== undefined) { - bodyContentHeight = Math.max( - bodyContentHeight - warningHeight, - MINIMUM_MAX_HEIGHT, - ); - } - + const tipText = `To auto-accept, press ${formatCommand(Command.CYCLE_APPROVAL_MODE)}`; warnings = ( - <> - - - - {REDIRECTION_WARNING_NOTE_LABEL} - {REDIRECTION_WARNING_NOTE_TEXT} - - - - - {REDIRECTION_WARNING_TIP_LABEL} - {tipText} - - - + + + Redirection detected.{' '} + {tipText} + + ); } - bodyContent = ( - - cmd.trim().split(/\s+/)[0]) + .filter(Boolean), + ), + ).join(', '); + + const allowQuestion = ( + + Allow execution of{' '} + - - {commandsToDisplay.map((cmd, idx) => ( - - {colorizeCode({ - code: cmd, - language: 'bash', - maxWidth: Math.max(terminalWidth, 1), - settings, - hideLineNumbers: true, - })} - - ))} - - + [{sanitizeForDisplay(commandNames)}] + + {'?'} + + ); + + question = ( + + {allowQuestion} {warnings} ); + + bodyContent = ( + <> + + + + {commandsToDisplay.map((cmd, idx) => ( + + {colorizeCode({ + code: cmd.trim(), + language: 'bash', + maxWidth: Math.max(terminalWidth, 1) - 6, + settings, + theme: activeTheme, + hideLineNumbers: true, + availableHeight: + bodyHeight !== undefined + ? Math.max(bodyHeight - 2, 2) + : undefined, + })} + + ))} + + + + + ); } else if (confirmationDetails.type === 'info') { + question = `Do you want to proceed?`; const infoProps = confirmationDetails; const displayUrls = infoProps.urls && @@ -768,8 +833,8 @@ export const ToolConfirmationMessage: React.FC< ); } else if (confirmationDetails.type === 'mcp') { - // mcp tool confirmation const mcpProps = confirmationDetails; + question = `Allow execution of MCP tool "${sanitizeForDisplay(mcpProps.toolName)}" from server "${sanitizeForDisplay(mcpProps.serverName)}"?`; bodyContent = ( @@ -790,7 +855,26 @@ export const ToolConfirmationMessage: React.FC< (press {expandDetailsHintKey} to collapse MCP tool details) - {mcpToolDetailsText} + + {colorizeCode({ + code: mcpToolDetailsText || '', + language: 'json', + maxWidth: Math.max(terminalWidth, 1) - 4, + settings, + theme: activeTheme, + hideLineNumbers: true, + availableHeight: + bodyHeight !== undefined + ? Math.max(bodyHeight - 2, 2) + : undefined, + })} + ) : ( @@ -819,7 +903,9 @@ export const ToolConfirmationMessage: React.FC< isTrustedFolder, allowPermanentApproval, settings, + activeTheme, config, + toolName, ]); const bodyOverflowDirection: 'top' | 'bottom' = @@ -827,6 +913,30 @@ export const ToolConfirmationMessage: React.FC< ? 'bottom' : 'top'; + const renderRadioItem = useCallback( + ( + item: RadioSelectItem, + { titleColor }: { titleColor: string }, + ) => { + if (item.value === ToolConfirmationOutcome.ProceedAlwaysAndSave) { + return ( + + {item.label}{' '} + + ~/.gemini/policies/auto-saved.toml + + + ); + } + return ( + + {item.label} + + ); + }, + [], + ); + if (confirmationDetails.type === 'edit') { if (confirmationDetails.isModifying) { return ( @@ -849,13 +959,8 @@ export const ToolConfirmationMessage: React.FC< } return ( - - {/* System message from hook */} - {confirmationDetails.systemMessage && ( + + {!!confirmationDetails.systemMessage && ( {confirmationDetails.systemMessage} @@ -867,7 +972,11 @@ export const ToolConfirmationMessage: React.FC< bodyContent ) : ( <> - + )} - - {question} - + {!!question && ( + + {typeof question === 'string' ? ( + {question} + ) : ( + question + )} + + )} diff --git a/packages/cli/src/ui/components/messages/ToolGroupMessage.test.tsx b/packages/cli/src/ui/components/messages/ToolGroupMessage.test.tsx index 7108d76154..94584879f9 100644 --- a/packages/cli/src/ui/components/messages/ToolGroupMessage.test.tsx +++ b/packages/cli/src/ui/components/messages/ToolGroupMessage.test.tsx @@ -10,6 +10,7 @@ import { ToolGroupMessage } from './ToolGroupMessage.js'; import { UPDATE_TOPIC_TOOL_NAME, TOPIC_PARAM_TITLE, + TOPIC_PARAM_SUMMARY, TOPIC_PARAM_STRATEGIC_INTENT, makeFakeConfig, CoreToolCallStatus, @@ -292,7 +293,7 @@ describe('', () => { name: UPDATE_TOPIC_TOOL_NAME, args: { [TOPIC_PARAM_TITLE]: 'Testing Topic', - summary: 'This is the summary', + [TOPIC_PARAM_SUMMARY]: 'This is the summary', }, }), ]; diff --git a/packages/cli/src/ui/components/messages/ToolMessage.test.tsx b/packages/cli/src/ui/components/messages/ToolMessage.test.tsx index d079a289ee..c7e5df8750 100644 --- a/packages/cli/src/ui/components/messages/ToolMessage.test.tsx +++ b/packages/cli/src/ui/components/messages/ToolMessage.test.tsx @@ -352,6 +352,7 @@ describe('', () => { underline: false, dim: false, inverse: false, + isUninitialized: false, }, ], ]; diff --git a/packages/cli/src/ui/components/messages/ToolResultDisplay.test.tsx b/packages/cli/src/ui/components/messages/ToolResultDisplay.test.tsx index 7e0f3125a5..f30c309898 100644 --- a/packages/cli/src/ui/components/messages/ToolResultDisplay.test.tsx +++ b/packages/cli/src/ui/components/messages/ToolResultDisplay.test.tsx @@ -28,6 +28,7 @@ describe('ToolResultDisplay', () => { underline: false, dim: false, inverse: false, + isUninitialized: false, }, ], ]; @@ -179,6 +180,7 @@ describe('ToolResultDisplay', () => { underline: false, dim: false, inverse: false, + isUninitialized: false, }, ], ]; @@ -275,6 +277,7 @@ describe('ToolResultDisplay', () => { underline: false, dim: false, inverse: false, + isUninitialized: false, }, ], [ @@ -287,6 +290,7 @@ describe('ToolResultDisplay', () => { underline: false, dim: false, inverse: false, + isUninitialized: false, }, ], [ @@ -299,6 +303,7 @@ describe('ToolResultDisplay', () => { underline: false, dim: false, inverse: false, + isUninitialized: false, }, ], [ @@ -311,6 +316,7 @@ describe('ToolResultDisplay', () => { underline: false, dim: false, inverse: false, + isUninitialized: false, }, ], [ @@ -323,6 +329,7 @@ describe('ToolResultDisplay', () => { underline: false, dim: false, inverse: false, + isUninitialized: false, }, ], ]; @@ -362,6 +369,7 @@ describe('ToolResultDisplay', () => { underline: false, dim: false, inverse: false, + isUninitialized: false, }, ]); const renderResult = await renderWithProviders( diff --git a/packages/cli/src/ui/components/messages/ToolResultDisplayOverflow.test.tsx b/packages/cli/src/ui/components/messages/ToolResultDisplayOverflow.test.tsx index a2494a0a8b..cd06d93616 100644 --- a/packages/cli/src/ui/components/messages/ToolResultDisplayOverflow.test.tsx +++ b/packages/cli/src/ui/components/messages/ToolResultDisplayOverflow.test.tsx @@ -74,6 +74,7 @@ describe('ToolResultDisplay Overflow', () => { underline: false, dim: false, inverse: false, + isUninitialized: false, }, ]); const { lastFrame, waitUntilReady, unmount } = await renderWithProviders( diff --git a/packages/cli/src/ui/components/messages/TopicMessage.test.tsx b/packages/cli/src/ui/components/messages/TopicMessage.test.tsx new file mode 100644 index 0000000000..5da630cb86 --- /dev/null +++ b/packages/cli/src/ui/components/messages/TopicMessage.test.tsx @@ -0,0 +1,114 @@ +/** + * @license + * Copyright 2026 Google LLC + * SPDX-License-Identifier: Apache-2.0 + */ + +import { describe, it, expect, vi } from 'vitest'; +import { TopicMessage } from './TopicMessage.js'; +import { renderWithProviders } from '../../../test-utils/render.js'; +import { + TOPIC_PARAM_TITLE, + TOPIC_PARAM_SUMMARY, + TOPIC_PARAM_STRATEGIC_INTENT, + CoreToolCallStatus, + UPDATE_TOPIC_TOOL_NAME, +} from '@google/gemini-cli-core'; + +describe('', () => { + const baseArgs = { + [TOPIC_PARAM_TITLE]: 'Test Topic', + [TOPIC_PARAM_STRATEGIC_INTENT]: 'This is the strategic intent.', + [TOPIC_PARAM_SUMMARY]: + 'This is the detailed summary that should be expandable.', + }; + + const renderTopic = async ( + args: Record, + height?: number, + toolActions?: { + isExpanded?: (callId: string) => boolean; + toggleExpansion?: (callId: string) => void; + }, + ) => + renderWithProviders( + , + { toolActions, mouseEventsEnabled: true }, + ); + + it('renders title and intent by default (collapsed)', async () => { + const { lastFrame } = await renderTopic(baseArgs, 40); + const frame = lastFrame(); + expect(frame).toContain('Test Topic:'); + expect(frame).toContain('This is the strategic intent.'); + expect(frame).not.toContain('This is the detailed summary'); + expect(frame).not.toContain('(ctrl+o to expand)'); + }); + + it('renders summary when globally expanded (Ctrl+O)', async () => { + const { lastFrame } = await renderTopic(baseArgs, undefined); + const frame = lastFrame(); + expect(frame).toContain('Test Topic:'); + expect(frame).toContain('This is the strategic intent.'); + expect(frame).toContain('This is the detailed summary'); + expect(frame).not.toContain('(ctrl+o to collapse)'); + }); + + it('renders summary when selectively expanded via context', async () => { + const isExpanded = vi.fn((id) => id === 'test-topic'); + const { lastFrame } = await renderTopic(baseArgs, 40, { isExpanded }); + const frame = lastFrame(); + expect(frame).toContain('Test Topic:'); + expect(frame).toContain('This is the detailed summary'); + expect(frame).not.toContain('(ctrl+o to collapse)'); + }); + + it('calls toggleExpansion when clicked', async () => { + const toggleExpansion = vi.fn(); + const { simulateClick } = await renderTopic(baseArgs, 40, { + toggleExpansion, + }); + + // In renderWithProviders, the component is wrapped in a Box with terminalWidth. + // The TopicMessage has marginLeft={2}. + // So col 5 should definitely hit the text content. + // row 1 is the first line of the TopicMessage. + await simulateClick(5, 1); + + expect(toggleExpansion).toHaveBeenCalledWith('test-topic'); + }); + + it('falls back to summary if strategic_intent is missing', async () => { + const args = { + [TOPIC_PARAM_TITLE]: 'Test Topic', + [TOPIC_PARAM_SUMMARY]: 'Only summary is present.', + }; + const { lastFrame } = await renderTopic(args, 40); + const frame = lastFrame(); + expect(frame).toContain('Test Topic:'); + expect(frame).toContain('Only summary is present.'); + expect(frame).not.toContain('(ctrl+o to expand)'); + }); + + it('renders only strategic_intent if summary is missing', async () => { + const args = { + [TOPIC_PARAM_TITLE]: 'Test Topic', + [TOPIC_PARAM_STRATEGIC_INTENT]: 'Only intent is present.', + }; + const { lastFrame } = await renderTopic(args, 40); + const frame = lastFrame(); + expect(frame).toContain('Test Topic:'); + expect(frame).toContain('Only intent is present.'); + expect(frame).not.toContain('(ctrl+o to expand)'); + }); +}); diff --git a/packages/cli/src/ui/components/messages/TopicMessage.tsx b/packages/cli/src/ui/components/messages/TopicMessage.tsx index 0aea7f5dbd..e58e60f6e1 100644 --- a/packages/cli/src/ui/components/messages/TopicMessage.tsx +++ b/packages/cli/src/ui/components/messages/TopicMessage.tsx @@ -5,7 +5,8 @@ */ import type React from 'react'; -import { Box, Text } from 'ink'; +import { useEffect, useId, useRef, useCallback } from 'react'; +import { Box, Text, type DOMElement } from 'ink'; import { UPDATE_TOPIC_TOOL_NAME, UPDATE_TOPIC_DISPLAY_NAME, @@ -15,31 +16,103 @@ import { } from '@google/gemini-cli-core'; import type { IndividualToolCallDisplay } from '../../types.js'; import { theme } from '../../semantic-colors.js'; +import { useOverflowActions } from '../../contexts/OverflowContext.js'; +import { useToolActions } from '../../contexts/ToolActionsContext.js'; +import { useMouseClick } from '../../hooks/useMouseClick.js'; interface TopicMessageProps extends IndividualToolCallDisplay { terminalWidth: number; + availableTerminalHeight?: number; + isExpandable?: boolean; } export const isTopicTool = (name: string): boolean => name === UPDATE_TOPIC_TOOL_NAME || name === UPDATE_TOPIC_DISPLAY_NAME; -export const TopicMessage: React.FC = ({ args }) => { +export const TopicMessage: React.FC = ({ + callId, + args, + availableTerminalHeight, + isExpandable = true, +}) => { + const { isExpanded: isExpandedInContext, toggleExpansion } = useToolActions(); + + // Expansion is active if either: + // 1. The individual callId is expanded in the ToolActionsContext + // 2. The entire turn is expanded (Ctrl+O) which sets availableTerminalHeight to undefined + const isExpanded = + (isExpandedInContext ? isExpandedInContext(callId) : false) || + availableTerminalHeight === undefined; + + const overflowActions = useOverflowActions(); + const uniqueId = useId(); + const overflowId = `topic-${uniqueId}`; + const containerRef = useRef(null); + const rawTitle = args?.[TOPIC_PARAM_TITLE]; const title = typeof rawTitle === 'string' ? rawTitle : undefined; - const rawIntent = - args?.[TOPIC_PARAM_STRATEGIC_INTENT] || args?.[TOPIC_PARAM_SUMMARY]; - const intent = typeof rawIntent === 'string' ? rawIntent : undefined; + + const rawStrategicIntent = args?.[TOPIC_PARAM_STRATEGIC_INTENT]; + const strategicIntent = + typeof rawStrategicIntent === 'string' ? rawStrategicIntent : undefined; + + const rawSummary = args?.[TOPIC_PARAM_SUMMARY]; + const summary = typeof rawSummary === 'string' ? rawSummary : undefined; + + // Top line intent: prefer strategic_intent, fallback to summary + const intent = strategicIntent || summary; + + // Extra summary: only if both exist and are different (or just summary if we want to show it below) + const hasExtraSummary = !!( + strategicIntent && + summary && + strategicIntent !== summary + ); + + const handleToggle = useCallback(() => { + if (toggleExpansion && hasExtraSummary) { + toggleExpansion(callId); + } + }, [toggleExpansion, hasExtraSummary, callId]); + + useMouseClick(containerRef, handleToggle, { + isActive: isExpandable && hasExtraSummary, + }); + + useEffect(() => { + // Only register if there is more content (summary) and it's currently hidden + const hasHiddenContent = isExpandable && hasExtraSummary && !isExpanded; + + if (hasHiddenContent && overflowActions) { + overflowActions.addOverflowingId(overflowId); + } else if (overflowActions) { + overflowActions.removeOverflowingId(overflowId); + } + + return () => { + overflowActions?.removeOverflowingId(overflowId); + }; + }, [isExpandable, hasExtraSummary, isExpanded, overflowActions, overflowId]); return ( - - - {title || 'Topic'} - {intent && : } - - {intent && ( - - {intent} + + + + {title || 'Topic'} + {intent && : } + {intent && ( + + {intent} + + )} + + {isExpanded && hasExtraSummary && summary && ( + + + {summary} + + )} ); diff --git a/packages/cli/src/ui/components/messages/__snapshots__/DiffRenderer.test.tsx.snap b/packages/cli/src/ui/components/messages/__snapshots__/DiffRenderer.test.tsx.snap index fed8b32bd0..7a36d3f840 100644 --- a/packages/cli/src/ui/components/messages/__snapshots__/DiffRenderer.test.tsx.snap +++ b/packages/cli/src/ui/components/messages/__snapshots__/DiffRenderer.test.tsx.snap @@ -50,11 +50,8 @@ exports[` > with useAlterna `; exports[` > with useAlternateBuffer = false > should handle diff with only header and no changes 1`] = ` -"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮ -│ │ -│ No changes detected. │ -│ │ -╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ +" + No changes detected. " `; @@ -143,11 +140,8 @@ exports[` > with useAlterna `; exports[` > with useAlternateBuffer = true > should handle diff with only header and no changes 1`] = ` -"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮ -│ │ -│ No changes detected. │ -│ │ -╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ +" + No changes detected. " `; diff --git a/packages/cli/src/ui/components/messages/__snapshots__/RedirectionConfirmation.test.tsx.snap b/packages/cli/src/ui/components/messages/__snapshots__/RedirectionConfirmation.test.tsx.snap index f584e7f483..1694ca2350 100644 --- a/packages/cli/src/ui/components/messages/__snapshots__/RedirectionConfirmation.test.tsx.snap +++ b/packages/cli/src/ui/components/messages/__snapshots__/RedirectionConfirmation.test.tsx.snap @@ -1,11 +1,11 @@ // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html exports[`ToolConfirmationMessage Redirection > should display redirection warning and tip for redirected commands 1`] = ` -"echo "hello" > test.txt - -Note: Command contains redirection which can be undesirable. -Tip: Toggle auto-edit (Shift+Tab) to allow redirection in the future. -Allow execution of: 'echo, redirection (>)'? +"╭──────────────────────────────────────────────────────────────────────────────────────────────────╮ +│ echo "hello" > test.txt │ +╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ +Allow execution of [echo]? +Redirection detected. To auto-accept, press Shift+Tab ● 1. Allow once 2. Allow for this session diff --git a/packages/cli/src/ui/components/messages/__snapshots__/ToolConfirmationMessage-ToolConfirmationMessage-height-allocation-and-layout-should-expand-to-available-height-for-large-edit-diffs.snap.svg b/packages/cli/src/ui/components/messages/__snapshots__/ToolConfirmationMessage-ToolConfirmationMessage-height-allocation-and-layout-should-expand-to-available-height-for-large-edit-diffs.snap.svg index 4c570fb451..ffc73fdd5e 100644 --- a/packages/cli/src/ui/components/messages/__snapshots__/ToolConfirmationMessage-ToolConfirmationMessage-height-allocation-and-layout-should-expand-to-available-height-for-large-edit-diffs.snap.svg +++ b/packages/cli/src/ui/components/messages/__snapshots__/ToolConfirmationMessage-ToolConfirmationMessage-height-allocation-and-layout-should-expand-to-available-height-for-large-edit-diffs.snap.svg @@ -1,468 +1,517 @@ - + - + - ... first 9 lines hidden (Ctrl+O to show) ... - - - 5 - - - + - - - const - - newLine5 = - - true - - ; - - - 6 + ╭──────────────────────────────────────────────────────────────────────────────╮ + │ + ... 10 hidden (Ctrl+O) ... + │ + │ - - + 6 - - const - - oldLine6 = - - true - - ; - - - 6 + + - + + + const + + oldLine6 = + + true + + ; + │ + │ - + + 6 - - const - - newLine6 = - - true - - ; - - - 7 + + + + + + const + + newLine6 = + + true + + ; + │ + │ - - + 7 - - const - - oldLine7 = - - true - - ; - - - 7 + + - + + + const + + oldLine7 = + + true + + ; + │ + │ - + + 7 - - const - - newLine7 = - - true - - ; - - - 8 + + + + + + const + + newLine7 = + + true + + ; + │ + │ - - + 8 - - const - - oldLine8 = - - true - - ; - - - 8 + + - + + + const + + oldLine8 = + + true + + ; + │ + │ - + + 8 - - const - - newLine8 = - - true - - ; - - - 9 + + + + + + const + + newLine8 = + + true + + ; + │ + │ - - + 9 - - const - - oldLine9 = - - true - - ; - - - 9 + + - + + + const + + oldLine9 = + + true + + ; + │ + │ - + + 9 - - const - - newLine9 = - - true - - ; - - 10 - - - - + + + + + + const + + newLine9 = + + true + + ; + │ + │ + + 10 - - const - - oldLine10 = - - true - - ; - - 10 - - - + + + - + + + const + + oldLine10 = + + true + + ; + │ + │ + + 10 - - const - - newLine10 = - - true - - ; - - 11 - - - - + + + + + + const + + newLine10 = + + true + + ; + │ + │ + + 11 - - const - - oldLine11 = - - true - - ; - - 11 - - - + + + - + + + const + + oldLine11 = + + true + + ; + │ + │ + + 11 - - const - - newLine11 = - - true - - ; - - 12 - - - - + + + + + + const + + newLine11 = + + true + + ; + │ + │ + + 12 - - const - - oldLine12 = - - true - - ; - - 12 - - - + + + - + + + const + + oldLine12 = + + true + + ; + │ + │ + + 12 - - const - - newLine12 = - - true - - ; - - 13 - - - - + + + + + + const + + newLine12 = + + true + + ; + │ + │ + + 13 - - const - - oldLine13 = - - true - - ; - - 13 - - - + + + - + + + const + + oldLine13 = + + true + + ; + │ + │ + + 13 - - const - - newLine13 = - - true - - ; - - 14 - - - - + + + + + + const + + newLine13 = + + true + + ; + │ + │ + + 14 - - const - - oldLine14 = - - true - - ; - - 14 - - - + + + - + + + const + + oldLine14 = + + true + + ; + │ + │ + + 14 - - const - - newLine14 = - - true - - ; - - 15 - - - - + + + + + + const + + newLine14 = + + true + + ; + │ + │ + + 15 - - const - - oldLine15 = - - true - - ; - - 15 - - - + + + - + + + const + + oldLine15 = + + true + + ; + │ + │ + + 15 - - const - - newLine15 = - - true - - ; - - 16 - - - - + + + + + + const + + newLine15 = + + true + + ; + │ + │ + + 16 - - const - - oldLine16 = - - true - - ; - - 16 - - - + + + - + + + const + + oldLine16 = + + true + + ; + │ + │ + + 16 - - const - - newLine16 = - - true - - ; - - 17 - - - - + + + + + + const + + newLine16 = + + true + + ; + │ + │ + + 17 - - const - - oldLine17 = - - true - - ; - - 17 - - - + + + - + + + const + + oldLine17 = + + true + + ; + │ + │ + + 17 - - const - - newLine17 = - - true - - ; - - 18 - - - - + + + + + + const + + newLine17 = + + true + + ; + │ + │ + + 18 - - const - - oldLine18 = - - true - - ; - - 18 - - - + + + - + + + const + + oldLine18 = + + true + + ; + │ + │ + + 18 - - const - - newLine18 = - - true - - ; - - 19 - - - - + + + + + + const + + newLine18 = + + true + + ; + │ + │ + + 19 - - const - - oldLine19 = - - true - - ; - - 19 - - - + + + - + + + const + + oldLine19 = + + true + + ; + │ + │ + + 19 - - const - - newLine19 = - - true - - ; - - 20 - - - - + + + + + + const + + newLine19 = + + true + + ; + │ + │ + + 20 - - const - - oldLine20 = - - true - - ; - - 20 - - - + + + - + + + const + + oldLine20 = + + true + + ; + │ + │ + + 20 - - const - - newLine20 = - - true - - ; - Apply this change? - - ● - - - 1. - - - Allow once - - 2. - Allow for this session - 3. - Modify with external editor - 4. - No, suggest changes (esc) + + + + + + const + + newLine20 = + + true + + ; + │ + ╰──────────────────────────────────────────────────────────────────────────────╯ + Apply this change? + + ● + + + 1. + + + Allow once + + 2. + Allow for this session + 3. + Modify with external editor + 4. + No, suggest changes (esc) \ No newline at end of file diff --git a/packages/cli/src/ui/components/messages/__snapshots__/ToolConfirmationMessage-ToolConfirmationMessage-height-allocation-and-layout-should-expand-to-available-height-for-large-exec-commands.snap.svg b/packages/cli/src/ui/components/messages/__snapshots__/ToolConfirmationMessage-ToolConfirmationMessage-height-allocation-and-layout-should-expand-to-available-height-for-large-exec-commands.snap.svg index 4b34a3405f..68e2eb2247 100644 --- a/packages/cli/src/ui/components/messages/__snapshots__/ToolConfirmationMessage-ToolConfirmationMessage-height-allocation-and-layout-should-expand-to-available-height-for-large-exec-commands.snap.svg +++ b/packages/cli/src/ui/components/messages/__snapshots__/ToolConfirmationMessage-ToolConfirmationMessage-height-allocation-and-layout-should-expand-to-available-height-for-large-exec-commands.snap.svg @@ -1,87 +1,151 @@ - + - + - ... first 18 lines hidden (Ctrl+O to show) ... - echo - "Line 19" - echo - "Line 20" - echo - "Line 21" - echo - "Line 22" - echo - "Line 23" - echo - "Line 24" - echo - "Line 25" - echo - "Line 26" - echo - "Line 27" - echo - "Line 28" - echo - "Line 29" - echo - "Line 30" - echo - "Line 31" - echo - "Line 32" - echo - "Line 33" - echo - "Line 34" - echo - "Line 35" - echo - "Line 36" - echo - "Line 37" - echo - "Line 38" - echo - "Line 39" - echo - "Line 40" - echo - "Line 41" - echo - "Line 42" - echo - "Line 43" - echo - "Line 44" - echo - "Line 45" - echo - "Line 46" - echo - "Line 47" - echo - "Line 48" - echo - "Line 49" - echo - "Line 50" - Allow execution of: 'echo'? - - ● - - - 1. - - - Allow once - - 2. - Allow for this session - 3. - No, suggest changes (esc) + ╭──────────────────────────────────────────────────────────────────────────────╮ + │ + ... 19 hidden (Ctrl+O) ... + │ + │ + echo + "Line 20" + │ + │ + echo + "Line 21" + │ + │ + echo + "Line 22" + │ + │ + echo + "Line 23" + │ + │ + echo + "Line 24" + │ + │ + echo + "Line 25" + │ + │ + echo + "Line 26" + │ + │ + echo + "Line 27" + │ + │ + echo + "Line 28" + │ + │ + echo + "Line 29" + │ + │ + echo + "Line 30" + │ + │ + echo + "Line 31" + │ + │ + echo + "Line 32" + │ + │ + echo + "Line 33" + │ + │ + echo + "Line 34" + │ + │ + echo + "Line 35" + │ + │ + echo + "Line 36" + │ + │ + echo + "Line 37" + │ + │ + echo + "Line 38" + │ + │ + echo + "Line 39" + │ + │ + echo + "Line 40" + │ + │ + echo + "Line 41" + │ + │ + echo + "Line 42" + │ + │ + echo + "Line 43" + │ + │ + echo + "Line 44" + │ + │ + echo + "Line 45" + │ + │ + echo + "Line 46" + │ + │ + echo + "Line 47" + │ + │ + echo + "Line 48" + │ + │ + echo + "Line 49" + │ + │ + echo + "Line 50" + │ + ╰──────────────────────────────────────────────────────────────────────────────╯ + Allow execution of [echo]? + + ● + + + 1. + + + Allow once + + 2. + Allow for this session + 3. + No, suggest changes (esc) \ No newline at end of file diff --git a/packages/cli/src/ui/components/messages/__snapshots__/ToolConfirmationMessage-ToolConfirmationMessage-should-render-multiline-shell-scripts-with-correct-newlines-and-syntax-highlighting.snap.svg b/packages/cli/src/ui/components/messages/__snapshots__/ToolConfirmationMessage-ToolConfirmationMessage-should-render-multiline-shell-scripts-with-correct-newlines-and-syntax-highlighting.snap.svg index d1396e2335..a30b871f41 100644 --- a/packages/cli/src/ui/components/messages/__snapshots__/ToolConfirmationMessage-ToolConfirmationMessage-should-render-multiline-shell-scripts-with-correct-newlines-and-syntax-highlighting.snap.svg +++ b/packages/cli/src/ui/components/messages/__snapshots__/ToolConfirmationMessage-ToolConfirmationMessage-should-render-multiline-shell-scripts-with-correct-newlines-and-syntax-highlighting.snap.svg @@ -1,32 +1,42 @@ - + - + - echo - "hello" - for - i - in - 1 2 3; - do - echo - $i - done - Allow execution of: 'echo'? - - ● - - - 1. - - - Allow once - - 2. - Allow for this session - 3. - No, suggest changes (esc) + ╭──────────────────────────────────────────────────────────────────────────────╮ + │ + echo + "hello" + │ + │ + for + i + in + 1 2 3; + do + │ + │ + echo + $i + │ + │ + done + │ + ╰──────────────────────────────────────────────────────────────────────────────╯ + Allow execution of [echo]? + + ● + + + 1. + + + Allow once + + 2. + Allow for this session + 3. + No, suggest changes (esc) \ No newline at end of file diff --git a/packages/cli/src/ui/components/messages/__snapshots__/ToolConfirmationMessage.test.tsx.snap b/packages/cli/src/ui/components/messages/__snapshots__/ToolConfirmationMessage.test.tsx.snap index eb9f856b0b..6d33b6fbfb 100644 --- a/packages/cli/src/ui/components/messages/__snapshots__/ToolConfirmationMessage.test.tsx.snap +++ b/packages/cli/src/ui/components/messages/__snapshots__/ToolConfirmationMessage.test.tsx.snap @@ -3,52 +3,53 @@ exports[`ToolConfirmationMessage > enablePermanentToolApproval setting > should show "Allow for all future sessions" when trusted 1`] = ` "╭──────────────────────────────────────────────────────────────────────────────╮ │ │ -│ No changes detected. │ +│ No changes detected. │ │ │ ╰──────────────────────────────────────────────────────────────────────────────╯ Apply this change? -● 1. Allow once +● 1. Allow once 2. Allow for this session - 3. Allow for this file in all future sessions + 3. Allow for this file in all future sessions ~/.gemini/policies/auto-saved.toml 4. Modify with external editor 5. No, suggest changes (esc) " `; exports[`ToolConfirmationMessage > height allocation and layout > should expand to available height for large edit diffs 1`] = ` -"... first 9 lines hidden (Ctrl+O to show) ... - 5 + const newLine5 = true; - 6 - const oldLine6 = true; - 6 + const newLine6 = true; - 7 - const oldLine7 = true; - 7 + const newLine7 = true; - 8 - const oldLine8 = true; - 8 + const newLine8 = true; - 9 - const oldLine9 = true; - 9 + const newLine9 = true; -10 - const oldLine10 = true; -10 + const newLine10 = true; -11 - const oldLine11 = true; -11 + const newLine11 = true; -12 - const oldLine12 = true; -12 + const newLine12 = true; -13 - const oldLine13 = true; -13 + const newLine13 = true; -14 - const oldLine14 = true; -14 + const newLine14 = true; -15 - const oldLine15 = true; -15 + const newLine15 = true; -16 - const oldLine16 = true; -16 + const newLine16 = true; -17 - const oldLine17 = true; -17 + const newLine17 = true; -18 - const oldLine18 = true; -18 + const newLine18 = true; -19 - const oldLine19 = true; -19 + const newLine19 = true; -20 - const oldLine20 = true; -20 + const newLine20 = true; +"╭──────────────────────────────────────────────────────────────────────────────╮ +│ ... 10 hidden (Ctrl+O) ... │ +│ 6 - const oldLine6 = true; │ +│ 6 + const newLine6 = true; │ +│ 7 - const oldLine7 = true; │ +│ 7 + const newLine7 = true; │ +│ 8 - const oldLine8 = true; │ +│ 8 + const newLine8 = true; │ +│ 9 - const oldLine9 = true; │ +│ 9 + const newLine9 = true; │ +│ 10 - const oldLine10 = true; │ +│ 10 + const newLine10 = true; │ +│ 11 - const oldLine11 = true; │ +│ 11 + const newLine11 = true; │ +│ 12 - const oldLine12 = true; │ +│ 12 + const newLine12 = true; │ +│ 13 - const oldLine13 = true; │ +│ 13 + const newLine13 = true; │ +│ 14 - const oldLine14 = true; │ +│ 14 + const newLine14 = true; │ +│ 15 - const oldLine15 = true; │ +│ 15 + const newLine15 = true; │ +│ 16 - const oldLine16 = true; │ +│ 16 + const newLine16 = true; │ +│ 17 - const oldLine17 = true; │ +│ 17 + const newLine17 = true; │ +│ 18 - const oldLine18 = true; │ +│ 18 + const newLine18 = true; │ +│ 19 - const oldLine19 = true; │ +│ 19 + const newLine19 = true; │ +│ 20 - const oldLine20 = true; │ +│ 20 + const newLine20 = true; │ +╰──────────────────────────────────────────────────────────────────────────────╯ Apply this change? ● 1. Allow once @@ -59,40 +60,41 @@ Apply this change? `; exports[`ToolConfirmationMessage > height allocation and layout > should expand to available height for large exec commands 1`] = ` -"... first 18 lines hidden (Ctrl+O to show) ... -echo "Line 19" -echo "Line 20" -echo "Line 21" -echo "Line 22" -echo "Line 23" -echo "Line 24" -echo "Line 25" -echo "Line 26" -echo "Line 27" -echo "Line 28" -echo "Line 29" -echo "Line 30" -echo "Line 31" -echo "Line 32" -echo "Line 33" -echo "Line 34" -echo "Line 35" -echo "Line 36" -echo "Line 37" -echo "Line 38" -echo "Line 39" -echo "Line 40" -echo "Line 41" -echo "Line 42" -echo "Line 43" -echo "Line 44" -echo "Line 45" -echo "Line 46" -echo "Line 47" -echo "Line 48" -echo "Line 49" -echo "Line 50" -Allow execution of: 'echo'? +"╭──────────────────────────────────────────────────────────────────────────────╮ +│ ... 19 hidden (Ctrl+O) ... │ +│ echo "Line 20" │ +│ echo "Line 21" │ +│ echo "Line 22" │ +│ echo "Line 23" │ +│ echo "Line 24" │ +│ echo "Line 25" │ +│ echo "Line 26" │ +│ echo "Line 27" │ +│ echo "Line 28" │ +│ echo "Line 29" │ +│ echo "Line 30" │ +│ echo "Line 31" │ +│ echo "Line 32" │ +│ echo "Line 33" │ +│ echo "Line 34" │ +│ echo "Line 35" │ +│ echo "Line 36" │ +│ echo "Line 37" │ +│ echo "Line 38" │ +│ echo "Line 39" │ +│ echo "Line 40" │ +│ echo "Line 41" │ +│ echo "Line 42" │ +│ echo "Line 43" │ +│ echo "Line 44" │ +│ echo "Line 45" │ +│ echo "Line 46" │ +│ echo "Line 47" │ +│ echo "Line 48" │ +│ echo "Line 49" │ +│ echo "Line 50" │ +╰──────────────────────────────────────────────────────────────────────────────╯ +Allow execution of [echo]? ● 1. Allow once 2. Allow for this session @@ -101,12 +103,14 @@ Allow execution of: 'echo'? `; exports[`ToolConfirmationMessage > should display multiple commands for exec type when provided 1`] = ` -"echo "hello" - -ls -la - -whoami -Allow execution of 3 commands? +"╭──────────────────────────────────────────────────────────────────────────────╮ +│ echo "hello" │ +│ │ +│ ls -la │ +│ │ +│ whoami │ +╰──────────────────────────────────────────────────────────────────────────────╯ +Allow execution of [echo, ls, whoami]? ● 1. Allow once 2. Allow for this session @@ -138,16 +142,17 @@ Do you want to proceed? `; exports[`ToolConfirmationMessage > should render multiline shell scripts with correct newlines and syntax highlighting 1`] = ` -"echo "hello" -for i in 1 2 3; do - echo $i -done -Allow execution of: 'echo'? +"╭──────────────────────────────────────────────────────────────────────────────╮ +│ echo "hello" │ +│ for i in 1 2 3; do │ +│ echo $i │ +│ done │ +╰──────────────────────────────────────────────────────────────────────────────╯ +Allow execution of [echo]? ● 1. Allow once 2. Allow for this session - 3. No, suggest changes (esc) -" + 3. No, suggest changes (esc)" `; exports[`ToolConfirmationMessage > should strip BiDi characters from MCP tool and server names 1`] = ` @@ -165,7 +170,7 @@ Allow execution of MCP tool "testtool" from server "testserver"? exports[`ToolConfirmationMessage > with folder trust > 'for edit confirmations' > should NOT show "allow always" when folder is untrusted 1`] = ` "╭──────────────────────────────────────────────────────────────────────────────╮ │ │ -│ No changes detected. │ +│ No changes detected. │ │ │ ╰──────────────────────────────────────────────────────────────────────────────╯ Apply this change? @@ -179,7 +184,7 @@ Apply this change? exports[`ToolConfirmationMessage > with folder trust > 'for edit confirmations' > should show "allow always" when folder is trusted 1`] = ` "╭──────────────────────────────────────────────────────────────────────────────╮ │ │ -│ No changes detected. │ +│ No changes detected. │ │ │ ╰──────────────────────────────────────────────────────────────────────────────╯ Apply this change? @@ -192,8 +197,10 @@ Apply this change? `; exports[`ToolConfirmationMessage > with folder trust > 'for exec confirmations' > should NOT show "allow always" when folder is untrusted 1`] = ` -"echo "hello" -Allow execution of: 'echo'? +"╭──────────────────────────────────────────────────────────────────────────────╮ +│ echo "hello" │ +╰──────────────────────────────────────────────────────────────────────────────╯ +Allow execution of [echo]? ● 1. Allow once 2. No, suggest changes (esc) @@ -201,8 +208,10 @@ Allow execution of: 'echo'? `; exports[`ToolConfirmationMessage > with folder trust > 'for exec confirmations' > should show "allow always" when folder is trusted 1`] = ` -"echo "hello" -Allow execution of: 'echo'? +"╭──────────────────────────────────────────────────────────────────────────────╮ +│ echo "hello" │ +╰──────────────────────────────────────────────────────────────────────────────╯ +Allow execution of [echo]? ● 1. Allow once 2. Allow for this session diff --git a/packages/cli/src/ui/components/messages/__snapshots__/ToolResultDisplay.test.tsx.snap b/packages/cli/src/ui/components/messages/__snapshots__/ToolResultDisplay.test.tsx.snap index 77d99b2792..12eff841b8 100644 --- a/packages/cli/src/ui/components/messages/__snapshots__/ToolResultDisplay.test.tsx.snap +++ b/packages/cli/src/ui/components/messages/__snapshots__/ToolResultDisplay.test.tsx.snap @@ -16,11 +16,8 @@ exports[`ToolResultDisplay > renders ANSI output result 1`] = ` `; exports[`ToolResultDisplay > renders file diff result 1`] = ` -"╭─────────────────────────────────────────────────────────────────────────╮ -│ │ -│ No changes detected. │ -│ │ -╰─────────────────────────────────────────────────────────────────────────╯ +" + No changes detected. " `; diff --git a/packages/cli/src/ui/components/shared/MaxSizedBox.tsx b/packages/cli/src/ui/components/shared/MaxSizedBox.tsx index 7aa40cfc62..baadb3b9d8 100644 --- a/packages/cli/src/ui/components/shared/MaxSizedBox.tsx +++ b/packages/cli/src/ui/components/shared/MaxSizedBox.tsx @@ -26,6 +26,7 @@ export interface MaxSizedBoxProps { maxHeight?: number; overflowDirection?: 'top' | 'bottom'; additionalHiddenLinesCount?: number; + paddingX?: number; } /** @@ -38,6 +39,7 @@ export const MaxSizedBox: React.FC = ({ maxHeight, overflowDirection = 'top', additionalHiddenLinesCount = 0, + paddingX = 0, }) => { const id = useId(); const { addOverflowingId, removeOverflowingId } = useOverflowActions() || {}; @@ -132,11 +134,13 @@ export const MaxSizedBox: React.FC = ({ flexShrink={0} > {totalHiddenLines > 0 && overflowDirection === 'top' && ( - - {isNarrow - ? `... ${totalHiddenLines} hidden (${showMoreKey}) ...` - : `... first ${totalHiddenLines} line${totalHiddenLines === 1 ? '' : 's'} hidden (${showMoreKey} to show) ...`} - + + + {isNarrow + ? `... ${totalHiddenLines} hidden (${showMoreKey}) ...` + : `... first ${totalHiddenLines} line${totalHiddenLines === 1 ? '' : 's'} hidden (${showMoreKey} to show) ...`} + + )} = ({ {totalHiddenLines > 0 && overflowDirection === 'bottom' && ( - - {isNarrow - ? `... ${totalHiddenLines} hidden (${showMoreKey}) ...` - : `... last ${totalHiddenLines} line${totalHiddenLines === 1 ? '' : 's'} hidden (${showMoreKey} to show) ...`} - + + + {isNarrow + ? `... ${totalHiddenLines} hidden (${showMoreKey}) ...` + : `... last ${totalHiddenLines} line${totalHiddenLines === 1 ? '' : 's'} hidden (${showMoreKey} to show) ...`} + + )} ); diff --git a/packages/cli/src/ui/components/shared/ScrollableList.tsx b/packages/cli/src/ui/components/shared/ScrollableList.tsx index 326005726f..c857e97b70 100644 --- a/packages/cli/src/ui/components/shared/ScrollableList.tsx +++ b/packages/cli/src/ui/components/shared/ScrollableList.tsx @@ -36,6 +36,9 @@ interface ScrollableListProps extends VirtualizedListProps { copyModeEnabled?: boolean; isStatic?: boolean; fixedItemHeight?: boolean; + targetScrollIndex?: number; + containerHeight?: number; + scrollbarThumbColor?: string; } export type ScrollableListRef = VirtualizedListRef; diff --git a/packages/cli/src/ui/components/shared/VirtualizedList.tsx b/packages/cli/src/ui/components/shared/VirtualizedList.tsx index e7b756b649..c3f888ba5f 100644 --- a/packages/cli/src/ui/components/shared/VirtualizedList.tsx +++ b/packages/cli/src/ui/components/shared/VirtualizedList.tsx @@ -29,6 +29,8 @@ export type VirtualizedListProps = { keyExtractor: (item: T, index: number) => string; initialScrollIndex?: number; initialScrollOffsetInIndex?: number; + targetScrollIndex?: number; + backgroundColor?: string; scrollbarThumbColor?: string; renderStatic?: boolean; isStatic?: boolean; @@ -39,6 +41,7 @@ export type VirtualizedListProps = { stableScrollback?: boolean; copyModeEnabled?: boolean; fixedItemHeight?: boolean; + containerHeight?: number; }; export type VirtualizedListRef = { @@ -82,32 +85,43 @@ const VirtualizedListItem = memo( width, containerWidth, itemKey, - itemRef, + index, + onSetRef, }: { content: React.ReactElement; shouldBeStatic: boolean; width: number | string | undefined; containerWidth: number; itemKey: string; - itemRef: (el: DOMElement | null) => void; - }) => ( - - {shouldBeStatic ? ( - - {content} - - ) : ( - content - )} - - ), + index: number; + onSetRef: (index: number, el: DOMElement | null) => void; + }) => { + const itemRef = useCallback( + (el: DOMElement | null) => { + onSetRef(index, el); + }, + [index, onSetRef], + ); + + return ( + + {shouldBeStatic ? ( + + {content} + + ) : ( + content + )} + + ); + }, ); VirtualizedListItem.displayName = 'VirtualizedListItem'; @@ -159,6 +173,17 @@ function VirtualizedList( }; } + if (typeof props.targetScrollIndex === 'number') { + // NOTE: When targetScrollIndex is specified, we rely on the component + // correctly tracking targetScrollIndex instead of initialScrollIndex. + // We set isInitialScrollSet.current = true inside the second layout effect + // to avoid it overwriting the targetScrollIndex. + return { + index: props.targetScrollIndex, + offset: 0, + }; + } + return { index: 0, offset: 0 }; }); @@ -181,6 +206,10 @@ function VirtualizedList( const containerObserverRef = useRef(null); const nodeToKeyRef = useRef(new WeakMap()); + const onSetRef = useCallback((index: number, el: DOMElement | null) => { + itemRefs.current[index] = el; + }, []); + const containerRefCallback = useCallback((node: DOMElement | null) => { containerObserverRef.current?.disconnect(); containerRef.current = node; @@ -242,7 +271,7 @@ function VirtualizedList( return { totalHeight, offsets }; }, [heights, data, estimatedItemHeight, keyExtractor]); - const scrollableContainerHeight = containerHeight; + const scrollableContainerHeight = props.containerHeight ?? containerHeight; const getAnchorForScrollTop = useCallback( ( @@ -259,6 +288,32 @@ function VirtualizedList( [], ); + const [prevTargetScrollIndex, setPrevTargetScrollIndex] = useState( + props.targetScrollIndex, + ); + const prevOffsetsLength = useRef(offsets.length); + + // NOTE: If targetScrollIndex is provided, and we haven't rendered items yet (offsets.length <= 1), + // we do NOT set scrollAnchor yet, because actualScrollTop wouldn't know the real offset! + // We wait until offsets populate. + if ( + (props.targetScrollIndex !== undefined && + props.targetScrollIndex !== prevTargetScrollIndex && + offsets.length > 1) || + (props.targetScrollIndex !== undefined && + prevOffsetsLength.current <= 1 && + offsets.length > 1) + ) { + if (props.targetScrollIndex !== prevTargetScrollIndex) { + setPrevTargetScrollIndex(props.targetScrollIndex); + } + prevOffsetsLength.current = offsets.length; + setIsStickingToBottom(false); + setScrollAnchor({ index: props.targetScrollIndex, offset: 0 }); + } else { + prevOffsetsLength.current = offsets.length; + } + const actualScrollTop = useMemo(() => { const offset = offsets[scrollAnchor.index]; if (typeof offset !== 'number') { @@ -309,9 +364,14 @@ function VirtualizedList( const containerChanged = prevContainerHeight.current !== scrollableContainerHeight; + // If targetScrollIndex is provided, we NEVER auto-snap to the bottom + // because the parent is explicitly managing the scroll position. + const shouldAutoScroll = props.targetScrollIndex === undefined; + if ( - (listGrew && (isStickingToBottom || wasAtBottom)) || - (isStickingToBottom && containerChanged) + shouldAutoScroll && + ((listGrew && (isStickingToBottom || wasAtBottom)) || + (isStickingToBottom && containerChanged)) ) { const newIndex = data.length > 0 ? data.length - 1 : 0; if ( @@ -331,6 +391,7 @@ function VirtualizedList( actualScrollTop > totalHeight - scrollableContainerHeight) && data.length > 0 ) { + // We still clamp the scroll top if it's completely out of bounds const newScrollTop = Math.max(0, totalHeight - scrollableContainerHeight); const newAnchor = getAnchorForScrollTop(newScrollTop, offsets); if ( @@ -359,6 +420,7 @@ function VirtualizedList( getAnchorForScrollTop, offsets, isStickingToBottom, + props.targetScrollIndex, ]); useLayoutEffect(() => { @@ -366,11 +428,17 @@ function VirtualizedList( isInitialScrollSet.current || offsets.length <= 1 || totalHeight <= 0 || - containerHeight <= 0 + scrollableContainerHeight <= 0 ) { return; } + if (props.targetScrollIndex !== undefined) { + // If we are strictly driving from targetScrollIndex, do not apply initialScrollIndex + isInitialScrollSet.current = true; + return; + } + if (typeof initialScrollIndex === 'number') { const scrollToEnd = initialScrollIndex === SCROLL_TO_ITEM_END || @@ -404,19 +472,21 @@ function VirtualizedList( initialScrollOffsetInIndex, offsets, totalHeight, - containerHeight, + scrollableContainerHeight, getAnchorForScrollTop, data.length, heights, - scrollableContainerHeight, + props.targetScrollIndex, ]); const startIndex = Math.max( 0, findLastIndex(offsets, (offset) => offset <= actualScrollTop) - 1, ); + const viewHeightForEndIndex = + scrollableContainerHeight > 0 ? scrollableContainerHeight : 50; const endIndexOffset = offsets.findIndex( - (offset) => offset > actualScrollTop + scrollableContainerHeight, + (offset) => offset > actualScrollTop + viewHeightForEndIndex, ); const endIndex = endIndexOffset === -1 @@ -462,7 +532,6 @@ function VirtualizedList( observedNodes.current = currentNodes; }); - const renderedItems = []; const renderRangeStart = renderStatic || overflowToBackbuffer ? 0 : startIndex; const renderRangeEnd = renderStatic ? data.length - 1 : endIndex; @@ -478,7 +547,12 @@ function VirtualizedList( process.env['NODE_ENV'] === 'test' || (width !== undefined && typeof width === 'number'); - if (isReady) { + const renderedItems = useMemo(() => { + if (!isReady) { + return []; + } + + const items = []; for (let i = renderRangeStart; i <= renderRangeEnd; i++) { const item = data[i]; if (item) { @@ -490,7 +564,7 @@ function VirtualizedList( const content = renderItem({ item, index: i }); const key = keyExtractor(item, i); - renderedItems.push( + items.push( ( shouldBeStatic={shouldBeStatic} width={width} containerWidth={containerWidth} - itemRef={(el: DOMElement | null) => { - if (i >= renderRangeStart && i <= renderRangeEnd) { - itemRefs.current[i] = el; - } - }} + index={i} + onSetRef={onSetRef} />, ); } } - } + return items; + }, [ + isReady, + renderRangeStart, + renderRangeEnd, + data, + startIndex, + endIndex, + renderStatic, + isStaticItem, + renderItem, + keyExtractor, + width, + containerWidth, + onSetRef, + ]); const { getScrollTop, setPendingScrollTop } = useBatchedScroll(scrollTop); @@ -618,11 +704,11 @@ function VirtualizedList( }, getScrollIndex: () => scrollAnchor.index, getScrollState: () => { - const maxScroll = Math.max(0, totalHeight - containerHeight); + const maxScroll = Math.max(0, totalHeight - scrollableContainerHeight); return { scrollTop: Math.min(getScrollTop(), maxScroll), scrollHeight: totalHeight, - innerHeight: containerHeight, + innerHeight: scrollableContainerHeight, }; }, }), @@ -635,7 +721,6 @@ function VirtualizedList( scrollableContainerHeight, getScrollTop, setPendingScrollTop, - containerHeight, ], ); @@ -646,6 +731,7 @@ function VirtualizedList( overflowX="hidden" scrollTop={copyModeEnabled ? 0 : scrollTop} scrollbarThumbColor={props.scrollbarThumbColor ?? theme.text.secondary} + backgroundColor={props.backgroundColor} width="100%" height="100%" flexDirection="column" diff --git a/packages/cli/src/ui/components/shared/text-buffer.ts b/packages/cli/src/ui/components/shared/text-buffer.ts index 72d842ec98..d6b95d6016 100644 --- a/packages/cli/src/ui/components/shared/text-buffer.ts +++ b/packages/cli/src/ui/components/shared/text-buffer.ts @@ -2907,6 +2907,25 @@ export function useTextBuffer({ const [scrollRowState, setScrollRowState] = useState(0); + const { height } = viewport; + const totalVisualLines = visualLines.length; + const maxScrollStart = Math.max(0, totalVisualLines - height); + let newVisualScrollRow = scrollRowState; + + if (visualCursor[0] < scrollRowState) { + newVisualScrollRow = visualCursor[0]; + } else if (visualCursor[0] >= scrollRowState + height) { + newVisualScrollRow = visualCursor[0] - height + 1; + } + + newVisualScrollRow = clamp(newVisualScrollRow, 0, maxScrollStart); + + if (newVisualScrollRow !== scrollRowState) { + setScrollRowState(newVisualScrollRow); + } + + const actualScrollRowState = newVisualScrollRow; + useEffect(() => { if (onChange) { onChange(text); @@ -2920,28 +2939,6 @@ export function useTextBuffer({ }); }, [viewport.width, viewport.height]); - // Update visual scroll (vertical) - useEffect(() => { - const { height } = viewport; - const totalVisualLines = visualLines.length; - const maxScrollStart = Math.max(0, totalVisualLines - height); - let newVisualScrollRow = scrollRowState; - - if (visualCursor[0] < scrollRowState) { - newVisualScrollRow = visualCursor[0]; - } else if (visualCursor[0] >= scrollRowState + height) { - newVisualScrollRow = visualCursor[0] - height + 1; - } - - // When the number of visual lines shrinks (e.g., after widening the viewport), - // ensure scroll never starts beyond the last valid start so we can render a full window. - newVisualScrollRow = clamp(newVisualScrollRow, 0, maxScrollStart); - - if (newVisualScrollRow !== scrollRowState) { - setScrollRowState(newVisualScrollRow); - } - }, [visualCursor, scrollRowState, viewport, visualLines.length]); - const insert = useCallback( (ch: string, { paste = false }: { paste?: boolean } = {}): void => { if (typeof ch !== 'string') { @@ -3495,10 +3492,10 @@ export function useTextBuffer({ const visualScrollRow = useMemo(() => { const totalVisualLines = visualLines.length; return Math.min( - scrollRowState, + actualScrollRowState, Math.max(0, totalVisualLines - viewport.height), ); - }, [visualLines.length, scrollRowState, viewport.height]); + }, [visualLines.length, actualScrollRowState, viewport.height]); const renderedVisualLines = useMemo( () => visualLines.slice(visualScrollRow, visualScrollRow + viewport.height), @@ -3694,6 +3691,7 @@ export function useTextBuffer({ viewportVisualLines: renderedVisualLines, visualCursor, visualScrollRow, + viewportHeight: viewport.height, visualToLogicalMap, transformedToLogicalMaps, visualToTransformedMap, @@ -3799,6 +3797,7 @@ export function useTextBuffer({ renderedVisualLines, visualCursor, visualScrollRow, + viewport.height, visualToLogicalMap, transformedToLogicalMaps, visualToTransformedMap, @@ -3914,6 +3913,7 @@ export interface TextBuffer { viewportVisualLines: string[]; // The subset of visual lines to be rendered based on visualScrollRow and viewport.height visualCursor: [number, number]; // Visual cursor [row, col] relative to the start of all visualLines visualScrollRow: number; // Scroll position for visual lines (index of the first visible visual line) + viewportHeight: number; // The maximum height of the viewport /** * For each visual line (by absolute index in allVisualLines) provides a tuple * [logicalLineIndex, startColInLogical] that maps where that visual line diff --git a/packages/cli/src/ui/contexts/InputContext.tsx b/packages/cli/src/ui/contexts/InputContext.tsx new file mode 100644 index 0000000000..45c1ff0672 --- /dev/null +++ b/packages/cli/src/ui/contexts/InputContext.tsx @@ -0,0 +1,28 @@ +/** + * @license + * Copyright 2026 Google LLC + * SPDX-License-Identifier: Apache-2.0 + */ + +import { createContext, useContext } from 'react'; +import type { TextBuffer } from '../components/shared/text-buffer.js'; + +export interface InputState { + buffer: TextBuffer; + userMessages: string[]; + shellModeActive: boolean; + showEscapePrompt: boolean; + copyModeEnabled: boolean | undefined; + inputWidth: number; + suggestionsWidth: number; +} + +export const InputContext = createContext(null); + +export const useInputState = () => { + const context = useContext(InputContext); + if (!context) { + throw new Error('useInputState must be used within an InputProvider'); + } + return context; +}; diff --git a/packages/cli/src/ui/contexts/SessionContext.tsx b/packages/cli/src/ui/contexts/SessionContext.tsx index 5ca37a1569..7f313bb443 100644 --- a/packages/cli/src/ui/contexts/SessionContext.tsx +++ b/packages/cli/src/ui/contexts/SessionContext.tsx @@ -17,6 +17,7 @@ import { import type { SessionMetrics, ModelMetrics, + RoleMetrics, ToolCallStats, } from '@google/gemini-cli-core'; import { uiTelemetryService, sessionId } from '@google/gemini-cli-core'; @@ -139,7 +140,7 @@ function areMetricsEqual(a: SessionMetrics, b: SessionMetrics): boolean { return true; } -export type { SessionMetrics, ModelMetrics }; +export type { SessionMetrics, ModelMetrics, RoleMetrics }; export interface SessionStatsState { sessionId: string; diff --git a/packages/cli/src/ui/contexts/UIStateContext.tsx b/packages/cli/src/ui/contexts/UIStateContext.tsx index 99d5874aba..3dd7e96467 100644 --- a/packages/cli/src/ui/contexts/UIStateContext.tsx +++ b/packages/cli/src/ui/contexts/UIStateContext.tsx @@ -17,7 +17,7 @@ import type { PermissionConfirmationRequest, } from '../types.js'; import type { CommandContext, SlashCommand } from '../commands/types.js'; -import type { TextBuffer } from '../components/shared/text-buffer.js'; + import type { IdeContext, ApprovalMode, @@ -143,11 +143,6 @@ export interface UIState { initError: string | null; pendingGeminiHistoryItems: HistoryItemWithoutId[]; thought: ThoughtSummary | null; - shellModeActive: boolean; - userMessages: string[]; - buffer: TextBuffer; - inputWidth: number; - suggestionsWidth: number; isInputActive: boolean; isResuming: boolean; shouldShowIdePrompt: boolean; @@ -162,7 +157,6 @@ export interface UIState { renderMarkdown: boolean; ctrlCPressedOnce: boolean; ctrlDPressedOnce: boolean; - showEscapePrompt: boolean; shortcutsHelpVisible: boolean; cleanUiDetailsVisible: boolean; elapsedTime: number; @@ -207,7 +201,6 @@ export interface UIState { embeddedShellFocused: boolean; showDebugProfiler: boolean; showFullTodos: boolean; - copyModeEnabled: boolean; bannerData: { defaultText: string; warningText: string; diff --git a/packages/cli/src/ui/hooks/useExecutionLifecycle.test.tsx b/packages/cli/src/ui/hooks/useExecutionLifecycle.test.tsx index d9af4fbcfa..34d05ebc70 100644 --- a/packages/cli/src/ui/hooks/useExecutionLifecycle.test.tsx +++ b/packages/cli/src/ui/hooks/useExecutionLifecycle.test.tsx @@ -541,6 +541,7 @@ describe('useExecutionLifecycle', () => { italic: false, underline: false, inverse: false, + isUninitialized: false, }, ], ]; diff --git a/packages/cli/src/ui/hooks/useExecutionLifecycle.ts b/packages/cli/src/ui/hooks/useExecutionLifecycle.ts index 4af4084813..2e80bf8f95 100644 --- a/packages/cli/src/ui/hooks/useExecutionLifecycle.ts +++ b/packages/cli/src/ui/hooks/useExecutionLifecycle.ts @@ -554,6 +554,7 @@ export const useExecutionLifecycle = ( italic: false, underline: false, inverse: false, + isUninitialized: false, }, ]); return [...newLines, [], ...output]; diff --git a/packages/cli/src/ui/layouts/DefaultAppLayout.test.tsx b/packages/cli/src/ui/layouts/DefaultAppLayout.test.tsx index 402ff501ad..6be2424194 100644 --- a/packages/cli/src/ui/layouts/DefaultAppLayout.test.tsx +++ b/packages/cli/src/ui/layouts/DefaultAppLayout.test.tsx @@ -5,8 +5,11 @@ */ import { render } from '../../test-utils/render.js'; -import { describe, it, expect, vi, beforeEach } from 'vitest'; import { DefaultAppLayout } from './DefaultAppLayout.js'; +import { describe, it, expect, vi, beforeEach } from 'vitest'; +import { useInputState } from '../contexts/InputContext.js'; + +vi.mock('../contexts/InputContext.js'); import { StreamingState } from '../types.js'; import { Text } from 'ink'; import type { UIState } from '../contexts/UIStateContext.js'; @@ -95,6 +98,9 @@ const createMockShell = (pid: number): BackgroundTask => ({ describe('', () => { beforeEach(() => { vi.clearAllMocks(); + vi.mocked(useInputState).mockReturnValue({ + copyModeEnabled: false, + } as unknown as ReturnType); // Reset mock state defaults mockUIState.backgroundTasks = new Map(); mockUIState.activeBackgroundTaskPid = null; diff --git a/packages/cli/src/ui/layouts/DefaultAppLayout.tsx b/packages/cli/src/ui/layouts/DefaultAppLayout.tsx index 964fb5ec55..bb1fc3e9b7 100644 --- a/packages/cli/src/ui/layouts/DefaultAppLayout.tsx +++ b/packages/cli/src/ui/layouts/DefaultAppLayout.tsx @@ -17,9 +17,11 @@ import { useAlternateBuffer } from '../hooks/useAlternateBuffer.js'; import { CopyModeWarning } from '../components/CopyModeWarning.js'; import { BackgroundTaskDisplay } from '../components/BackgroundTaskDisplay.js'; import { StreamingState } from '../types.js'; +import { useInputState } from '../contexts/InputContext.js'; export const DefaultAppLayout: React.FC = () => { const uiState = useUIState(); + const { copyModeEnabled } = useInputState(); const isAlternateBuffer = useAlternateBuffer(); const { rootUiRef, terminalHeight } = uiState; @@ -62,9 +64,7 @@ export const DefaultAppLayout: React.FC = () => { flexShrink={0} flexGrow={0} width={uiState.terminalWidth} - height={ - uiState.copyModeEnabled ? uiState.stableControlsHeight : undefined - } + height={copyModeEnabled ? uiState.stableControlsHeight : undefined} > diff --git a/packages/cli/src/ui/utils/CodeColorizer.tsx b/packages/cli/src/ui/utils/CodeColorizer.tsx index 828e041493..07d6429dbe 100644 --- a/packages/cli/src/ui/utils/CodeColorizer.tsx +++ b/packages/cli/src/ui/utils/CodeColorizer.tsx @@ -136,6 +136,7 @@ export interface ColorizeCodeOptions { hideLineNumbers?: boolean; disableColor?: boolean; returnLines?: boolean; + paddingX?: number; } /** @@ -160,6 +161,7 @@ export function colorizeCode({ hideLineNumbers = false, disableColor = false, returnLines = false, + paddingX = 0, }: ColorizeCodeOptions): React.ReactNode | React.ReactNode[] { const codeToHighlight = code.replace(/\n$/, ''); const activeTheme = theme || themeManager.getActiveTheme(); @@ -167,26 +169,29 @@ export function colorizeCode({ ? false : settings.merged.ui.showLineNumbers; - const useMaxSizedBox = !settings.merged.ui.useAlternateBuffer && !returnLines; + // We force MaxSizedBox if availableHeight is provided, even if alternate buffer is enabled, + // because this might be rendered in a constrained UI box (like tool confirmation). + const useMaxSizedBox = + (!settings.merged.ui.useAlternateBuffer || availableHeight !== undefined) && + !returnLines; + + let hiddenLinesCount = 0; + let finalLines = codeToHighlight.split(/\r?\n/); + try { - // Render the HAST tree using the adapted theme - // Apply the theme's default foreground color to the top-level Text element - let lines = codeToHighlight.split(/\r?\n/); - const padWidth = String(lines.length).length; // Calculate padding width based on number of lines - - let hiddenLinesCount = 0; - // Optimization to avoid highlighting lines that cannot possibly be displayed. if (availableHeight !== undefined && useMaxSizedBox) { availableHeight = Math.max(availableHeight, MINIMUM_MAX_HEIGHT); - if (lines.length > availableHeight) { - const sliceIndex = lines.length - availableHeight; + if (finalLines.length > availableHeight) { + const sliceIndex = finalLines.length - availableHeight; hiddenLinesCount = sliceIndex; - lines = lines.slice(sliceIndex); + finalLines = finalLines.slice(sliceIndex); } } - const renderedLines = lines.map((line, index) => { + const padWidth = String(finalLines.length + hiddenLinesCount).length; + + const renderedLines = finalLines.map((line, index) => { const contentToRender = disableColor ? line : highlightAndRenderLine(line, language, activeTheme); @@ -223,6 +228,7 @@ export function colorizeCode({ if (useMaxSizedBox) { return ( ( + const padWidth = String(finalLines.length + hiddenLinesCount).length; + const fallbackLines = finalLines.map((line, index) => ( {showLineNumbers && ( - {`${index + 1}`} + {`${index + 1 + hiddenLinesCount}`} )} @@ -275,8 +279,10 @@ export function colorizeCode({ if (useMaxSizedBox) { return ( {fallbackLines} diff --git a/packages/cli/src/utils/sessionUtils.test.ts b/packages/cli/src/utils/sessionUtils.test.ts index 5eeeef9bd3..e1cd1137fa 100644 --- a/packages/cli/src/utils/sessionUtils.test.ts +++ b/packages/cli/src/utils/sessionUtils.test.ts @@ -11,11 +11,13 @@ import { formatRelativeTime, hasUserOrAssistantMessage, SessionError, + convertSessionToHistoryFormats, } from './sessionUtils.js'; import { SESSION_FILE_PREFIX, type Config, type MessageRecord, + CoreToolCallStatus, } from '@google/gemini-cli-core'; import * as fs from 'node:fs/promises'; import path from 'node:path'; @@ -806,3 +808,188 @@ describe('formatRelativeTime', () => { expect(formatRelativeTime(thirtySecondsAgo.toISOString())).toBe('Just now'); }); }); + +describe('convertSessionToHistoryFormats', () => { + it('should preserve tool call arguments', () => { + const messages: MessageRecord[] = [ + { + id: '1', + timestamp: new Date().toISOString(), + type: 'gemini', + content: '', + toolCalls: [ + { + id: 'call_1', + name: 'update_topic', + args: { + title: 'Researching bug', + summary: 'I am looking into the issue.', + }, + status: CoreToolCallStatus.Success, + timestamp: new Date().toISOString(), + displayName: 'Update Topic Context', + description: 'Updating the topic', + renderOutputAsMarkdown: true, + resultDisplay: 'Topic updated', + }, + ], + }, + ]; + + const result = convertSessionToHistoryFormats(messages); + + expect(result.uiHistory).toHaveLength(1); + const toolGroup = result.uiHistory[0]; + if (toolGroup.type === 'tool_group') { + expect(toolGroup.tools).toHaveLength(1); + const tool = toolGroup.tools[0]; + expect(tool.callId).toBe('call_1'); + expect(tool.name).toBe('Update Topic Context'); + expect(tool.description).toBe('Updating the topic'); + expect(tool.renderOutputAsMarkdown).toBe(true); + expect(tool.status).toBe(CoreToolCallStatus.Success); + expect(tool.resultDisplay).toBe('Topic updated'); + expect(tool.args).toEqual({ + title: 'Researching bug', + summary: 'I am looking into the issue.', + }); + } else { + throw new Error('Expected tool_group history item'); + } + }); + + it('should map tool call status correctly when not success', () => { + const messages: MessageRecord[] = [ + { + id: '1', + timestamp: new Date().toISOString(), + type: 'gemini', + content: '', + toolCalls: [ + { + id: 'call_1', + name: 'test_tool', + status: CoreToolCallStatus.Error, + timestamp: new Date().toISOString(), + args: {}, + }, + { + id: 'call_2', + name: 'test_tool_2', + status: CoreToolCallStatus.Cancelled, + timestamp: new Date().toISOString(), + args: {}, + }, + ], + }, + ]; + + const result = convertSessionToHistoryFormats(messages); + expect(result.uiHistory).toHaveLength(1); + + const toolGroup = result.uiHistory[0]; + if (toolGroup.type === 'tool_group') { + expect(toolGroup.tools).toHaveLength(2); + expect(toolGroup.tools[0].status).toBe(CoreToolCallStatus.Error); + expect(toolGroup.tools[1].status).toBe(CoreToolCallStatus.Error); // Cancelled maps to error in this older format projection + } else { + throw new Error('Expected tool_group history item'); + } + }); + + it('should convert various message types', () => { + const messages: MessageRecord[] = [ + { + id: '1', + timestamp: new Date().toISOString(), + type: 'user', + content: 'Hello user', + }, + { + id: '2', + timestamp: new Date().toISOString(), + type: 'info', + content: 'System info', + }, + { + id: '3', + timestamp: new Date().toISOString(), + type: 'error', + content: 'System error', + }, + { + id: '4', + timestamp: new Date().toISOString(), + type: 'warning', + content: 'System warning', + }, + { + id: '5', + timestamp: new Date().toISOString(), + type: 'gemini', + content: 'Hello gemini', + thoughts: [ + { + subject: 'Thinking', + description: 'about things', + timestamp: new Date().toISOString(), + }, + ], + }, + ]; + + const result = convertSessionToHistoryFormats(messages); + + // thoughts become a separate item + expect(result.uiHistory).toHaveLength(6); + expect(result.uiHistory[0]).toEqual({ type: 'user', text: 'Hello user' }); + expect(result.uiHistory[1]).toEqual({ type: 'info', text: 'System info' }); + expect(result.uiHistory[2]).toEqual({ + type: 'error', + text: 'System error', + }); + expect(result.uiHistory[3]).toEqual({ + type: 'warning', + text: 'System warning', + }); + expect(result.uiHistory[4]).toEqual({ + type: 'thinking', + thought: { subject: 'Thinking', description: 'about things' }, + }); + expect(result.uiHistory[5]).toEqual({ + type: 'gemini', + text: 'Hello gemini', + }); + }); + + it('should handle missing tool descriptions and displayNames', () => { + const messages: MessageRecord[] = [ + { + id: '1', + timestamp: new Date().toISOString(), + type: 'gemini', + content: '', + toolCalls: [ + { + id: 'call_1', + name: 'test_tool', + status: CoreToolCallStatus.Success, + timestamp: new Date().toISOString(), + args: {}, + }, + ], + }, + ]; + + const result = convertSessionToHistoryFormats(messages); + expect(result.uiHistory).toHaveLength(1); + + const toolGroup = result.uiHistory[0]; + if (toolGroup.type === 'tool_group') { + expect(toolGroup.tools[0].name).toBe('test_tool'); // Fallback to name + expect(toolGroup.tools[0].description).toBe(''); // Fallback to empty string + } else { + throw new Error('Expected tool_group history item'); + } + }); +}); diff --git a/packages/cli/src/utils/sessionUtils.ts b/packages/cli/src/utils/sessionUtils.ts index ca6685f47d..cf95b0f545 100644 --- a/packages/cli/src/utils/sessionUtils.ts +++ b/packages/cli/src/utils/sessionUtils.ts @@ -607,6 +607,7 @@ export function convertSessionToHistoryFormats( tools: msg.toolCalls.map((tool) => ({ callId: tool.id, name: tool.displayName || tool.name, + args: tool.args, description: tool.description || '', renderOutputAsMarkdown: tool.renderOutputAsMarkdown ?? true, status: diff --git a/packages/core/src/agents/browser/browserAgentFactory.ts b/packages/core/src/agents/browser/browserAgentFactory.ts index b341ce6836..e07f403ba7 100644 --- a/packages/core/src/agents/browser/browserAgentFactory.ts +++ b/packages/core/src/agents/browser/browserAgentFactory.ts @@ -32,11 +32,11 @@ import { createAnalyzeScreenshotTool } from './analyzeScreenshot.js'; import { injectAutomationOverlay } from './automationOverlay.js'; import { injectInputBlocker } from './inputBlocker.js'; import { debugLogger } from '../../utils/debugLogger.js'; +import { recordBrowserAgentToolDiscovery } from '../../telemetry/metrics.js'; import { - recordBrowserAgentToolDiscovery, - recordBrowserAgentVisionStatus, - recordBrowserAgentCleanup, -} from '../../telemetry/metrics.js'; + logBrowserAgentVisionStatus, + logBrowserAgentCleanup, +} from '../../telemetry/loggers.js'; import { PolicyDecision, PRIORITY_SUBAGENT_TOOL, @@ -248,7 +248,7 @@ export async function createBrowserAgentDefinition( const allTools: AnyDeclarativeTool[] = [...mcpTools]; const visionDisabledReason = getVisionDisabledReason(); - recordBrowserAgentVisionStatus(config, { + logBrowserAgentVisionStatus(config, { enabled: !visionDisabledReason, disabled_reason: visionDisabledReason?.code, }); @@ -299,13 +299,13 @@ export async function cleanupBrowserAgent( const startMs = Date.now(); try { await browserManager.close(); - recordBrowserAgentCleanup(config, Date.now() - startMs, { + logBrowserAgentCleanup(config, Date.now() - startMs, { session_mode: sessionMode, success: true, }); debugLogger.log('Browser agent cleanup complete'); } catch (error) { - recordBrowserAgentCleanup(config, Date.now() - startMs, { + logBrowserAgentCleanup(config, Date.now() - startMs, { session_mode: sessionMode, success: false, }); diff --git a/packages/core/src/agents/browser/browserAgentInvocation.test.ts b/packages/core/src/agents/browser/browserAgentInvocation.test.ts index ba15fdd184..a87b88cb1b 100644 --- a/packages/core/src/agents/browser/browserAgentInvocation.test.ts +++ b/packages/core/src/agents/browser/browserAgentInvocation.test.ts @@ -742,7 +742,7 @@ describe('BrowserAgentInvocation', () => { ); }); - it('should call cleanupBrowserAgent with correct params', async () => { + it('should not call cleanupBrowserAgent (cleanup is handled by BrowserManager.resetAll)', async () => { const invocation = new BrowserAgentInvocation( mockConfig, mockParams, @@ -750,11 +750,7 @@ describe('BrowserAgentInvocation', () => { ); await invocation.execute(new AbortController().signal, vi.fn()); - expect(cleanupBrowserAgent).toHaveBeenCalledWith( - expect.anything(), - mockConfig, - 'persistent', - ); + expect(cleanupBrowserAgent).not.toHaveBeenCalled(); }); }); diff --git a/packages/core/src/agents/browser/browserAgentInvocation.ts b/packages/core/src/agents/browser/browserAgentInvocation.ts index 61f361ac67..6fb05753ee 100644 --- a/packages/core/src/agents/browser/browserAgentInvocation.ts +++ b/packages/core/src/agents/browser/browserAgentInvocation.ts @@ -34,12 +34,9 @@ import { isToolActivityError, } from '../types.js'; import type { MessageBus } from '../../confirmation-bus/message-bus.js'; -import { - createBrowserAgentDefinition, - cleanupBrowserAgent, -} from './browserAgentFactory.js'; +import { createBrowserAgentDefinition } from './browserAgentFactory.js'; import { removeInputBlocker } from './inputBlocker.js'; -import { recordBrowserAgentTaskOutcome } from '../../telemetry/metrics.js'; +import { logBrowserAgentTaskOutcome } from '../../telemetry/loggers.js'; import { sanitizeThoughtContent, sanitizeToolArgs, @@ -400,7 +397,7 @@ ${output.result}`; }, }; } finally { - recordBrowserAgentTaskOutcome(this.config, { + logBrowserAgentTaskOutcome(this.config, { success: taskSuccess, session_mode: sessionMode, vision_enabled: visionEnabled, @@ -444,7 +441,6 @@ ${output.result}`; } catch { // Ignore errors for removing the overlays. } - await cleanupBrowserAgent(browserManager, this.config, sessionMode); } } } diff --git a/packages/core/src/agents/browser/browserManager.test.ts b/packages/core/src/agents/browser/browserManager.test.ts index 8ddcf1836d..baabc80bcb 100644 --- a/packages/core/src/agents/browser/browserManager.test.ts +++ b/packages/core/src/agents/browser/browserManager.test.ts @@ -373,6 +373,7 @@ describe('BrowserManager', () => { session_mode: 'persistent', headless: false, success: true, + tool_count: 4, }, ); }); diff --git a/packages/core/src/agents/browser/browserManager.ts b/packages/core/src/agents/browser/browserManager.ts index 08e4cc2ae9..89d54e9c72 100644 --- a/packages/core/src/agents/browser/browserManager.ts +++ b/packages/core/src/agents/browser/browserManager.ts @@ -30,7 +30,7 @@ import * as path from 'node:path'; import * as fs from 'node:fs'; import { fileURLToPath } from 'node:url'; import { injectAutomationOverlay } from './automationOverlay.js'; -import { recordBrowserAgentConnection } from '../../telemetry/metrics.js'; +import { logBrowserAgentConnection } from '../../telemetry/loggers.js'; const __filename = fileURLToPath(import.meta.url); const __dirname = path.dirname(__filename); @@ -563,7 +563,9 @@ export class BrowserManager { // Add optional settings from config. // Force headless in seatbelt sandbox since Chrome profile/display access // may be restricted, and the user is running in a sandboxed environment. - if (browserConfig.customConfig.headless || isSeatbeltSandbox) { + const effectiveHeadless = + !!browserConfig.customConfig.headless || isSeatbeltSandbox; + if (effectiveHeadless) { mcpArgs.push('--headless'); } if (browserConfig.customConfig.profilePath) { @@ -667,15 +669,12 @@ export class BrowserManager { // clear the action counter for each connection this.actionCounter = 0; - recordBrowserAgentConnection( - this.config, - Date.now() - connectStartMs, - { - session_mode: sessionMode, - headless: !!browserConfig.customConfig.headless, - success: true, - }, - ); + logBrowserAgentConnection(this.config, Date.now() - connectStartMs, { + session_mode: sessionMode, + headless: effectiveHeadless, + success: true, + tool_count: this.discoveredTools.length, + }); })(), new Promise((_, reject) => { timeoutId = setTimeout( @@ -696,9 +695,9 @@ export class BrowserManager { error instanceof Error ? error.message : String(error); const errorType = BrowserManager.classifyConnectionError(rawErrorMessage); - recordBrowserAgentConnection(this.config, Date.now() - connectStartMs, { + logBrowserAgentConnection(this.config, Date.now() - connectStartMs, { session_mode: sessionMode, - headless: !!browserConfig.customConfig.headless, + headless: effectiveHeadless, success: false, error_type: errorType, }); diff --git a/packages/core/src/agents/local-executor.ts b/packages/core/src/agents/local-executor.ts index 50a93ec7ff..81cd27abee 100644 --- a/packages/core/src/agents/local-executor.ts +++ b/packages/core/src/agents/local-executor.ts @@ -30,7 +30,7 @@ import { CompressionStatus } from '../core/turn.js'; import { type ToolCallRequestInfo } from '../scheduler/types.js'; import { ChatCompressionService } from '../context/chatCompressionService.js'; import { getDirectoryContextString } from '../utils/environmentContext.js'; -import { renderUserMemory } from '../prompts/snippets.js'; +import { renderUserMemory, renderAgentSkills } from '../prompts/snippets.js'; import { promptIdContext } from '../utils/promptIdContext.js'; import { logAgentStart, @@ -78,7 +78,10 @@ import { runWithScopedWorkspaceContext, } from '../config/scoped-config.js'; import { CompleteTaskTool } from '../tools/complete-task.js'; -import { COMPLETE_TASK_TOOL_NAME } from '../tools/definitions/base-declarations.js'; +import { + COMPLETE_TASK_TOOL_NAME, + ACTIVATE_SKILL_TOOL_NAME, +} from '../tools/definitions/base-declarations.js'; /** A callback function to report on agent activity. */ export type ActivityCallback = (activity: SubagentActivityEvent) => void; @@ -1318,6 +1321,21 @@ export class LocalAgentExecutor { // Inject user inputs into the prompt template. let finalPrompt = templateString(promptConfig.systemPrompt, inputs); + // Inject skill SI if ACTIVATE_SKILL_TOOL_NAME is available to this agent. + if (this.toolRegistry.getTool(ACTIVATE_SKILL_TOOL_NAME) !== undefined) { + const skills = this.context.config.getSkillManager().getSkills(); + if (skills.length > 0) { + const skillsPrompt = renderAgentSkills( + skills.map((s) => ({ + name: s.name, + description: s.description, + location: s.location, + })), + ); + finalPrompt += `\n\n${skillsPrompt}`; + } + } + // Append memory context if available. const systemMemory = this.context.config.getSystemInstructionMemory(); if (systemMemory) { diff --git a/packages/core/src/config/config.test.ts b/packages/core/src/config/config.test.ts index 386f42754f..002d4da50e 100644 --- a/packages/core/src/config/config.test.ts +++ b/packages/core/src/config/config.test.ts @@ -1579,7 +1579,9 @@ describe('Server Config (config.ts)', () => { }); expect(config.getSandboxEnabled()).toBe(false); - expect(config.getSandboxAllowedPaths()).toEqual([]); + expect(config.getSandboxAllowedPaths()).toEqual([ + Storage.getGlobalTempDir(), + ]); expect(config.getSandboxNetworkAccess()).toBe(false); }); @@ -1597,7 +1599,11 @@ describe('Server Config (config.ts)', () => { }); expect(config.getSandboxEnabled()).toBe(true); - expect(config.getSandboxAllowedPaths()).toEqual(['/tmp/foo', '/var/bar']); + expect(config.getSandboxAllowedPaths()).toEqual([ + '/tmp/foo', + '/var/bar', + Storage.getGlobalTempDir(), + ]); expect(config.getSandboxNetworkAccess()).toBe(true); expect(config.getSandbox()?.command).toBe('docker'); expect(config.getSandbox()?.image).toBe('my-image'); @@ -1614,7 +1620,10 @@ describe('Server Config (config.ts)', () => { }); expect(config.getSandboxEnabled()).toBe(true); - expect(config.getSandboxAllowedPaths()).toEqual(['/only/this']); + expect(config.getSandboxAllowedPaths()).toEqual([ + '/only/this', + Storage.getGlobalTempDir(), + ]); expect(config.getSandboxNetworkAccess()).toBe(false); }); diff --git a/packages/core/src/config/config.ts b/packages/core/src/config/config.ts index 9e9133bb82..efb3e296df 100644 --- a/packages/core/src/config/config.ts +++ b/packages/core/src/config/config.ts @@ -508,6 +508,7 @@ export enum AuthProviderType { export interface SandboxConfig { enabled: boolean; allowedPaths?: string[]; + includeDirectories?: string[]; networkAccess?: boolean; command?: | 'docker' @@ -524,6 +525,7 @@ export const ConfigSchema = z.object({ .object({ enabled: z.boolean().default(false), allowedPaths: z.array(z.string()).default([]), + includeDirectories: z.array(z.string()).default([]), networkAccess: z.boolean().default(false), command: z .enum([ @@ -965,6 +967,11 @@ export class Config implements McpContext, AgentLoopContext { ? { enabled: params.sandbox.enabled || params.toolSandboxing || false, allowedPaths: params.sandbox.allowedPaths ?? [], + includeDirectories: [ + ...(params.sandbox.includeDirectories ?? []), + ...(params.sandbox.allowedPaths ?? []), + Storage.getGlobalTempDir(), + ], networkAccess: params.sandbox.networkAccess ?? false, command: params.sandbox.command, image: params.sandbox.image, @@ -972,6 +979,7 @@ export class Config implements McpContext, AgentLoopContext { : { enabled: params.toolSandboxing || false, allowedPaths: [], + includeDirectories: [Storage.getGlobalTempDir()], networkAccess: false, }; @@ -994,7 +1002,10 @@ export class Config implements McpContext, AgentLoopContext { { workspace: this.targetDir, forbiddenPaths: this.getSandboxForbiddenPaths.bind(this), - includeDirectories: this.pendingIncludeDirectories, + includeDirectories: [ + ...this.pendingIncludeDirectories, + Storage.getGlobalTempDir(), + ], policyManager: this._sandboxPolicyManager, }, initialApprovalMode, @@ -1002,7 +1013,7 @@ export class Config implements McpContext, AgentLoopContext { if ( !(this._sandboxManager instanceof NoopSandboxManager) && - this.sandbox.enabled + this.sandbox?.enabled ) { this.fileSystemService = new SandboxedFileSystemService( this._sandboxManager, @@ -1702,7 +1713,10 @@ export class Config implements McpContext, AgentLoopContext { { workspace: this.targetDir, forbiddenPaths: this.getSandboxForbiddenPaths.bind(this), - includeDirectories: this.pendingIncludeDirectories, + includeDirectories: [ + ...this.pendingIncludeDirectories, + Storage.getGlobalTempDir(), + ], policyManager: this._sandboxPolicyManager, }, this.getApprovalMode(), @@ -1981,7 +1995,12 @@ export class Config implements McpContext, AgentLoopContext { } getSandboxAllowedPaths(): string[] { - return this.sandbox?.allowedPaths ?? []; + const paths = [...(this.sandbox?.allowedPaths ?? [])]; + const globalTempDir = Storage.getGlobalTempDir(); + if (!paths.includes(globalTempDir)) { + paths.push(globalTempDir); + } + return paths; } getSandboxNetworkAccess(): boolean { diff --git a/packages/core/src/core/__snapshots__/prompts.test.ts.snap b/packages/core/src/core/__snapshots__/prompts.test.ts.snap index 91e2573e62..86c5151721 100644 --- a/packages/core/src/core/__snapshots__/prompts.test.ts.snap +++ b/packages/core/src/core/__snapshots__/prompts.test.ts.snap @@ -42,7 +42,8 @@ Use the following guidelines to optimize your search and read patterns. ## Engineering Standards - **Contextual Precedence:** Instructions found in \`GEMINI.md\` files are foundational mandates. They take absolute precedence over the general workflows and tool defaults described in this system prompt. - **Conventions & Style:** Rigorously adhere to existing workspace conventions, architectural patterns, and style (naming, formatting, typing, commenting). During the research phase, analyze surrounding files, tests, and configuration to ensure your changes are seamless, idiomatic, and consistent with the local context. Never compromise idiomatic quality or completeness (e.g., proper declarations, type safety, documentation) to minimize tool calls; all supporting changes required by local conventions are part of a surgical update. -- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings or bypassing the type system (i.e.: casts in TypeScript) unless explicitly instructed to by the user. Instead, use idiomatic language features (e.g.: type guard functions). +- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Libraries/Frameworks:** NEVER assume a library/framework is available. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', etc.) before employing it. - **Technical Integrity:** You are responsible for the entire lifecycle: implementation, testing, and validation. Within the scope of your changes, prioritize readability and long-term maintainability by consolidating logic into clean abstractions rather than threading state across unrelated layers. Align strictly with the requested architectural direction, ensuring the final implementation is focused and free of redundant "just-in-case" alternatives. Validation is not merely running tests; it is the exhaustive process of ensuring that every aspect of your change—behavioral, structural, and stylistic—is correct and fully compatible with the broader project. For bug fixes, you must empirically reproduce the failure with a new test case or reproduction script before applying the fix. - **Expertise & Intent Alignment:** Provide proactive technical opinions grounded in research while strictly adhering to the user's intended workflow. Distinguish between **Directives** (unambiguous requests for action or implementation) and **Inquiries** (requests for analysis, advice, or observations). Assume all requests are Inquiries unless they contain an explicit instruction to perform a task. For Inquiries, your scope is strictly limited to research and analysis; you may propose a solution or strategy, but you MUST NOT modify files until a corresponding Directive is issued. Do not initiate implementation based on observations of bugs or statements of fact. Once an Inquiry is resolved, or while waiting for a Directive, stop and wait for the next user instruction. For Directives, only clarify if critically underspecified; otherwise, work autonomously. You should only seek user intervention if you have exhausted all possible routes or if a proposed solution would take the workspace in a significantly different architectural direction. @@ -219,7 +220,8 @@ Use the following guidelines to optimize your search and read patterns. ## Engineering Standards - **Contextual Precedence:** Instructions found in \`GEMINI.md\` files are foundational mandates. They take absolute precedence over the general workflows and tool defaults described in this system prompt. - **Conventions & Style:** Rigorously adhere to existing workspace conventions, architectural patterns, and style (naming, formatting, typing, commenting). During the research phase, analyze surrounding files, tests, and configuration to ensure your changes are seamless, idiomatic, and consistent with the local context. Never compromise idiomatic quality or completeness (e.g., proper declarations, type safety, documentation) to minimize tool calls; all supporting changes required by local conventions are part of a surgical update. -- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings or bypassing the type system (i.e.: casts in TypeScript) unless explicitly instructed to by the user. Instead, use idiomatic language features (e.g.: type guard functions). +- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Libraries/Frameworks:** NEVER assume a library/framework is available. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', etc.) before employing it. - **Technical Integrity:** You are responsible for the entire lifecycle: implementation, testing, and validation. Within the scope of your changes, prioritize readability and long-term maintainability by consolidating logic into clean abstractions rather than threading state across unrelated layers. Align strictly with the requested architectural direction, ensuring the final implementation is focused and free of redundant "just-in-case" alternatives. Validation is not merely running tests; it is the exhaustive process of ensuring that every aspect of your change—behavioral, structural, and stylistic—is correct and fully compatible with the broader project. For bug fixes, you must empirically reproduce the failure with a new test case or reproduction script before applying the fix. - **Expertise & Intent Alignment:** Provide proactive technical opinions grounded in research while strictly adhering to the user's intended workflow. Distinguish between **Directives** (unambiguous requests for action or implementation) and **Inquiries** (requests for analysis, advice, or observations). Assume all requests are Inquiries unless they contain an explicit instruction to perform a task. For Inquiries, your scope is strictly limited to research and analysis; you may propose a solution or strategy, but you MUST NOT modify files until a corresponding Directive is issued. Do not initiate implementation based on observations of bugs or statements of fact. Once an Inquiry is resolved, or while waiting for a Directive, stop and wait for the next user instruction. For Directives, only clarify if critically underspecified; otherwise, work autonomously. You should only seek user intervention if you have exhausted all possible routes or if a proposed solution would take the workspace in a significantly different architectural direction. @@ -369,6 +371,8 @@ exports[`Core System Prompt (prompts.ts) > ApprovalMode in System Prompt > shoul - **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', 'build.gradle', etc., or observe neighboring files) before employing it. - **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project. - **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically. +- **Types, Warnings & Linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Comments:** Add code comments sparingly. Focus on *why* something is done, especially for complex logic, rather than *what* is done. Only add high-value comments if necessary for clarity or if requested by the user. Do not edit comments that are separate from the code you are changing. *NEVER* talk to the user or describe your changes through comments. - **Proactiveness:** Fulfill the user's request thoroughly. When adding features or fixing bugs, this includes adding tests to ensure quality. Consider all created files, especially tests, to be permanent artifacts unless the user says otherwise. - **User Hints:** During execution, the user may provide real-time hints (marked as "User hint:" or "User hints:"). Treat these as high-priority but scope-preserving course corrections: apply the minimal plan change needed, keep unaffected user tasks active, and never cancel/skip tasks unless cancellation is explicit for those tasks. Hints may add new tasks, modify one or more tasks, cancel specific tasks, or provide extra context only. If scope is ambiguous, ask for clarification before dropping work. @@ -515,7 +519,8 @@ Use the following guidelines to optimize your search and read patterns. ## Engineering Standards - **Contextual Precedence:** Instructions found in \`GEMINI.md\` files are foundational mandates. They take absolute precedence over the general workflows and tool defaults described in this system prompt. - **Conventions & Style:** Rigorously adhere to existing workspace conventions, architectural patterns, and style (naming, formatting, typing, commenting). During the research phase, analyze surrounding files, tests, and configuration to ensure your changes are seamless, idiomatic, and consistent with the local context. Never compromise idiomatic quality or completeness (e.g., proper declarations, type safety, documentation) to minimize tool calls; all supporting changes required by local conventions are part of a surgical update. -- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings or bypassing the type system (i.e.: casts in TypeScript) unless explicitly instructed to by the user. Instead, use idiomatic language features (e.g.: type guard functions). +- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Libraries/Frameworks:** NEVER assume a library/framework is available. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', etc.) before employing it. - **Technical Integrity:** You are responsible for the entire lifecycle: implementation, testing, and validation. Within the scope of your changes, prioritize readability and long-term maintainability by consolidating logic into clean abstractions rather than threading state across unrelated layers. Align strictly with the requested architectural direction, ensuring the final implementation is focused and free of redundant "just-in-case" alternatives. Validation is not merely running tests; it is the exhaustive process of ensuring that every aspect of your change—behavioral, structural, and stylistic—is correct and fully compatible with the broader project. For bug fixes, you must empirically reproduce the failure with a new test case or reproduction script before applying the fix. - **Expertise & Intent Alignment:** Provide proactive technical opinions grounded in research while strictly adhering to the user's intended workflow. Distinguish between **Directives** (unambiguous requests for action or implementation) and **Inquiries** (requests for analysis, advice, or observations). Assume all requests are Inquiries unless they contain an explicit instruction to perform a task. For Inquiries, your scope is strictly limited to research and analysis; you may propose a solution or strategy, but you MUST NOT modify files until a corresponding Directive is issued. Do not initiate implementation based on observations of bugs or statements of fact. Once an Inquiry is resolved, or while waiting for a Directive, stop and wait for the next user instruction. For Directives, only clarify if critically underspecified; otherwise, work autonomously. You should only seek user intervention if you have exhausted all possible routes or if a proposed solution would take the workspace in a significantly different architectural direction. @@ -692,7 +697,8 @@ Use the following guidelines to optimize your search and read patterns. ## Engineering Standards - **Contextual Precedence:** Instructions found in \`GEMINI.md\` files are foundational mandates. They take absolute precedence over the general workflows and tool defaults described in this system prompt. - **Conventions & Style:** Rigorously adhere to existing workspace conventions, architectural patterns, and style (naming, formatting, typing, commenting). During the research phase, analyze surrounding files, tests, and configuration to ensure your changes are seamless, idiomatic, and consistent with the local context. Never compromise idiomatic quality or completeness (e.g., proper declarations, type safety, documentation) to minimize tool calls; all supporting changes required by local conventions are part of a surgical update. -- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings or bypassing the type system (i.e.: casts in TypeScript) unless explicitly instructed to by the user. Instead, use idiomatic language features (e.g.: type guard functions). +- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Libraries/Frameworks:** NEVER assume a library/framework is available. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', etc.) before employing it. - **Technical Integrity:** You are responsible for the entire lifecycle: implementation, testing, and validation. Within the scope of your changes, prioritize readability and long-term maintainability by consolidating logic into clean abstractions rather than threading state across unrelated layers. Align strictly with the requested architectural direction, ensuring the final implementation is focused and free of redundant "just-in-case" alternatives. Validation is not merely running tests; it is the exhaustive process of ensuring that every aspect of your change—behavioral, structural, and stylistic—is correct and fully compatible with the broader project. For bug fixes, you must empirically reproduce the failure with a new test case or reproduction script before applying the fix. - **Expertise & Intent Alignment:** Provide proactive technical opinions grounded in research while strictly adhering to the user's intended workflow. Distinguish between **Directives** (unambiguous requests for action or implementation) and **Inquiries** (requests for analysis, advice, or observations). Assume all requests are Inquiries unless they contain an explicit instruction to perform a task. For Inquiries, your scope is strictly limited to research and analysis; you may propose a solution or strategy, but you MUST NOT modify files until a corresponding Directive is issued. Do not initiate implementation based on observations of bugs or statements of fact. Once an Inquiry is resolved, or while waiting for a Directive, stop and wait for the next user instruction. For Directives, only clarify if critically underspecified; otherwise, work autonomously. You should only seek user intervention if you have exhausted all possible routes or if a proposed solution would take the workspace in a significantly different architectural direction. @@ -867,7 +873,8 @@ Use the following guidelines to optimize your search and read patterns. ## Engineering Standards - **Contextual Precedence:** Instructions found in \`GEMINI.md\` files are foundational mandates. They take absolute precedence over the general workflows and tool defaults described in this system prompt. - **Conventions & Style:** Rigorously adhere to existing workspace conventions, architectural patterns, and style (naming, formatting, typing, commenting). During the research phase, analyze surrounding files, tests, and configuration to ensure your changes are seamless, idiomatic, and consistent with the local context. Never compromise idiomatic quality or completeness (e.g., proper declarations, type safety, documentation) to minimize tool calls; all supporting changes required by local conventions are part of a surgical update. -- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings or bypassing the type system (i.e.: casts in TypeScript) unless explicitly instructed to by the user. Instead, use idiomatic language features (e.g.: type guard functions). +- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Libraries/Frameworks:** NEVER assume a library/framework is available. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', etc.) before employing it. - **Technical Integrity:** You are responsible for the entire lifecycle: implementation, testing, and validation. Within the scope of your changes, prioritize readability and long-term maintainability by consolidating logic into clean abstractions rather than threading state across unrelated layers. Align strictly with the requested architectural direction, ensuring the final implementation is focused and free of redundant "just-in-case" alternatives. Validation is not merely running tests; it is the exhaustive process of ensuring that every aspect of your change—behavioral, structural, and stylistic—is correct and fully compatible with the broader project. For bug fixes, you must empirically reproduce the failure with a new test case or reproduction script before applying the fix. - **Expertise & Intent Alignment:** Provide proactive technical opinions grounded in research while strictly adhering to the user's intended workflow. Distinguish between **Directives** (unambiguous requests for action or implementation) and **Inquiries** (requests for analysis, advice, or observations). Assume all requests are Inquiries unless they contain an explicit instruction to perform a task. For Inquiries, your scope is strictly limited to research and analysis; you may propose a solution or strategy, but you MUST NOT modify files until a corresponding Directive is issued. Do not initiate implementation based on observations of bugs or statements of fact. Once an Inquiry is resolved, or while waiting for a Directive, stop and wait for the next user instruction. For Directives, you must work autonomously as no further user input is available. You should only seek user intervention if you have exhausted all possible routes or if a proposed solution would take the workspace in a significantly different architectural direction. @@ -994,7 +1001,8 @@ Use the following guidelines to optimize your search and read patterns. ## Engineering Standards - **Contextual Precedence:** Instructions found in \`GEMINI.md\` files are foundational mandates. They take absolute precedence over the general workflows and tool defaults described in this system prompt. - **Conventions & Style:** Rigorously adhere to existing workspace conventions, architectural patterns, and style (naming, formatting, typing, commenting). During the research phase, analyze surrounding files, tests, and configuration to ensure your changes are seamless, idiomatic, and consistent with the local context. Never compromise idiomatic quality or completeness (e.g., proper declarations, type safety, documentation) to minimize tool calls; all supporting changes required by local conventions are part of a surgical update. -- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings or bypassing the type system (i.e.: casts in TypeScript) unless explicitly instructed to by the user. Instead, use idiomatic language features (e.g.: type guard functions). +- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Libraries/Frameworks:** NEVER assume a library/framework is available. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', etc.) before employing it. - **Technical Integrity:** You are responsible for the entire lifecycle: implementation, testing, and validation. Within the scope of your changes, prioritize readability and long-term maintainability by consolidating logic into clean abstractions rather than threading state across unrelated layers. Align strictly with the requested architectural direction, ensuring the final implementation is focused and free of redundant "just-in-case" alternatives. Validation is not merely running tests; it is the exhaustive process of ensuring that every aspect of your change—behavioral, structural, and stylistic—is correct and fully compatible with the broader project. For bug fixes, you must empirically reproduce the failure with a new test case or reproduction script before applying the fix. - **Expertise & Intent Alignment:** Provide proactive technical opinions grounded in research while strictly adhering to the user's intended workflow. Distinguish between **Directives** (unambiguous requests for action or implementation) and **Inquiries** (requests for analysis, advice, or observations). Assume all requests are Inquiries unless they contain an explicit instruction to perform a task. For Inquiries, your scope is strictly limited to research and analysis; you may propose a solution or strategy, but you MUST NOT modify files until a corresponding Directive is issued. Do not initiate implementation based on observations of bugs or statements of fact. Once an Inquiry is resolved, or while waiting for a Directive, stop and wait for the next user instruction. For Directives, you must work autonomously as no further user input is available. You should only seek user intervention if you have exhausted all possible routes or if a proposed solution would take the workspace in a significantly different architectural direction. @@ -1088,6 +1096,8 @@ exports[`Core System Prompt (prompts.ts) > should handle git instructions when i - **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', 'build.gradle', etc., or observe neighboring files) before employing it. - **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project. - **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically. +- **Types, Warnings & Linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Comments:** Add code comments sparingly. Focus on *why* something is done, especially for complex logic, rather than *what* is done. Only add high-value comments if necessary for clarity or if requested by the user. Do not edit comments that are separate from the code you are changing. *NEVER* talk to the user or describe your changes through comments. - **Proactiveness:** Fulfill the user's request thoroughly. When adding features or fixing bugs, this includes adding tests to ensure quality. Consider all created files, especially tests, to be permanent artifacts unless the user says otherwise. - **User Hints:** During execution, the user may provide real-time hints (marked as "User hint:" or "User hints:"). Treat these as high-priority but scope-preserving course corrections: apply the minimal plan change needed, keep unaffected user tasks active, and never cancel/skip tasks unless cancellation is explicit for those tasks. Hints may add new tasks, modify one or more tasks, cancel specific tasks, or provide extra context only. If scope is ambiguous, ask for clarification before dropping work. @@ -1201,6 +1211,8 @@ exports[`Core System Prompt (prompts.ts) > should handle git instructions when i - **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', 'build.gradle', etc., or observe neighboring files) before employing it. - **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project. - **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically. +- **Types, Warnings & Linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Comments:** Add code comments sparingly. Focus on *why* something is done, especially for complex logic, rather than *what* is done. Only add high-value comments if necessary for clarity or if requested by the user. Do not edit comments that are separate from the code you are changing. *NEVER* talk to the user or describe your changes through comments. - **Proactiveness:** Fulfill the user's request thoroughly. When adding features or fixing bugs, this includes adding tests to ensure quality. Consider all created files, especially tests, to be permanent artifacts unless the user says otherwise. - **User Hints:** During execution, the user may provide real-time hints (marked as "User hint:" or "User hints:"). Treat these as high-priority but scope-preserving course corrections: apply the minimal plan change needed, keep unaffected user tasks active, and never cancel/skip tasks unless cancellation is explicit for those tasks. Hints may add new tasks, modify one or more tasks, cancel specific tasks, or provide extra context only. If scope is ambiguous, ask for clarification before dropping work. @@ -1332,6 +1344,8 @@ exports[`Core System Prompt (prompts.ts) > should include approved plan instruct - **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', 'build.gradle', etc., or observe neighboring files) before employing it. - **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project. - **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically. +- **Types, Warnings & Linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Comments:** Add code comments sparingly. Focus on *why* something is done, especially for complex logic, rather than *what* is done. Only add high-value comments if necessary for clarity or if requested by the user. Do not edit comments that are separate from the code you are changing. *NEVER* talk to the user or describe your changes through comments. - **Proactiveness:** Fulfill the user's request thoroughly. When adding features or fixing bugs, this includes adding tests to ensure quality. Consider all created files, especially tests, to be permanent artifacts unless the user says otherwise. - **User Hints:** During execution, the user may provide real-time hints (marked as "User hint:" or "User hints:"). Treat these as high-priority but scope-preserving course corrections: apply the minimal plan change needed, keep unaffected user tasks active, and never cancel/skip tasks unless cancellation is explicit for those tasks. Hints may add new tasks, modify one or more tasks, cancel specific tasks, or provide extra context only. If scope is ambiguous, ask for clarification before dropping work. @@ -1435,6 +1449,8 @@ exports[`Core System Prompt (prompts.ts) > should include available_skills when - **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', 'build.gradle', etc., or observe neighboring files) before employing it. - **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project. - **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically. +- **Types, Warnings & Linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Comments:** Add code comments sparingly. Focus on *why* something is done, especially for complex logic, rather than *what* is done. Only add high-value comments if necessary for clarity or if requested by the user. Do not edit comments that are separate from the code you are changing. *NEVER* talk to the user or describe your changes through comments. - **Proactiveness:** Fulfill the user's request thoroughly. When adding features or fixing bugs, this includes adding tests to ensure quality. Consider all created files, especially tests, to be permanent artifacts unless the user says otherwise. - **User Hints:** During execution, the user may provide real-time hints (marked as "User hint:" or "User hints:"). Treat these as high-priority but scope-preserving course corrections: apply the minimal plan change needed, keep unaffected user tasks active, and never cancel/skip tasks unless cancellation is explicit for those tasks. Hints may add new tasks, modify one or more tasks, cancel specific tasks, or provide extra context only. If scope is ambiguous, ask for clarification before dropping work. @@ -1594,7 +1610,8 @@ Use the following guidelines to optimize your search and read patterns. ## Engineering Standards - **Contextual Precedence:** Instructions found in \`GEMINI.md\` files are foundational mandates. They take absolute precedence over the general workflows and tool defaults described in this system prompt. - **Conventions & Style:** Rigorously adhere to existing workspace conventions, architectural patterns, and style (naming, formatting, typing, commenting). During the research phase, analyze surrounding files, tests, and configuration to ensure your changes are seamless, idiomatic, and consistent with the local context. Never compromise idiomatic quality or completeness (e.g., proper declarations, type safety, documentation) to minimize tool calls; all supporting changes required by local conventions are part of a surgical update. -- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings or bypassing the type system (i.e.: casts in TypeScript) unless explicitly instructed to by the user. Instead, use idiomatic language features (e.g.: type guard functions). +- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Libraries/Frameworks:** NEVER assume a library/framework is available. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', etc.) before employing it. - **Technical Integrity:** You are responsible for the entire lifecycle: implementation, testing, and validation. Within the scope of your changes, prioritize readability and long-term maintainability by consolidating logic into clean abstractions rather than threading state across unrelated layers. Align strictly with the requested architectural direction, ensuring the final implementation is focused and free of redundant "just-in-case" alternatives. Validation is not merely running tests; it is the exhaustive process of ensuring that every aspect of your change—behavioral, structural, and stylistic—is correct and fully compatible with the broader project. For bug fixes, you must empirically reproduce the failure with a new test case or reproduction script before applying the fix. - **Expertise & Intent Alignment:** Provide proactive technical opinions grounded in research while strictly adhering to the user's intended workflow. Distinguish between **Directives** (unambiguous requests for action or implementation) and **Inquiries** (requests for analysis, advice, or observations). Assume all requests are Inquiries unless they contain an explicit instruction to perform a task. For Inquiries, your scope is strictly limited to research and analysis; you may propose a solution or strategy, but you MUST NOT modify files until a corresponding Directive is issued. Do not initiate implementation based on observations of bugs or statements of fact. Once an Inquiry is resolved, or while waiting for a Directive, stop and wait for the next user instruction. For Directives, only clarify if critically underspecified; otherwise, work autonomously. You should only seek user intervention if you have exhausted all possible routes or if a proposed solution would take the workspace in a significantly different architectural direction. @@ -1765,7 +1782,8 @@ Use the following guidelines to optimize your search and read patterns. ## Engineering Standards - **Contextual Precedence:** Instructions found in \`GEMINI.md\` files are foundational mandates. They take absolute precedence over the general workflows and tool defaults described in this system prompt. - **Conventions & Style:** Rigorously adhere to existing workspace conventions, architectural patterns, and style (naming, formatting, typing, commenting). During the research phase, analyze surrounding files, tests, and configuration to ensure your changes are seamless, idiomatic, and consistent with the local context. Never compromise idiomatic quality or completeness (e.g., proper declarations, type safety, documentation) to minimize tool calls; all supporting changes required by local conventions are part of a surgical update. -- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings or bypassing the type system (i.e.: casts in TypeScript) unless explicitly instructed to by the user. Instead, use idiomatic language features (e.g.: type guard functions). +- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Libraries/Frameworks:** NEVER assume a library/framework is available. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', etc.) before employing it. - **Technical Integrity:** You are responsible for the entire lifecycle: implementation, testing, and validation. Within the scope of your changes, prioritize readability and long-term maintainability by consolidating logic into clean abstractions rather than threading state across unrelated layers. Align strictly with the requested architectural direction, ensuring the final implementation is focused and free of redundant "just-in-case" alternatives. Validation is not merely running tests; it is the exhaustive process of ensuring that every aspect of your change—behavioral, structural, and stylistic—is correct and fully compatible with the broader project. For bug fixes, you must empirically reproduce the failure with a new test case or reproduction script before applying the fix. - **Expertise & Intent Alignment:** Provide proactive technical opinions grounded in research while strictly adhering to the user's intended workflow. Distinguish between **Directives** (unambiguous requests for action or implementation) and **Inquiries** (requests for analysis, advice, or observations). Assume all requests are Inquiries unless they contain an explicit instruction to perform a task. For Inquiries, your scope is strictly limited to research and analysis; you may propose a solution or strategy, but you MUST NOT modify files until a corresponding Directive is issued. Do not initiate implementation based on observations of bugs or statements of fact. Once an Inquiry is resolved, or while waiting for a Directive, stop and wait for the next user instruction. For Directives, only clarify if critically underspecified; otherwise, work autonomously. You should only seek user intervention if you have exhausted all possible routes or if a proposed solution would take the workspace in a significantly different architectural direction. @@ -1927,7 +1945,8 @@ Use the following guidelines to optimize your search and read patterns. ## Engineering Standards - **Contextual Precedence:** Instructions found in \`GEMINI.md\` files are foundational mandates. They take absolute precedence over the general workflows and tool defaults described in this system prompt. - **Conventions & Style:** Rigorously adhere to existing workspace conventions, architectural patterns, and style (naming, formatting, typing, commenting). During the research phase, analyze surrounding files, tests, and configuration to ensure your changes are seamless, idiomatic, and consistent with the local context. Never compromise idiomatic quality or completeness (e.g., proper declarations, type safety, documentation) to minimize tool calls; all supporting changes required by local conventions are part of a surgical update. -- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings or bypassing the type system (i.e.: casts in TypeScript) unless explicitly instructed to by the user. Instead, use idiomatic language features (e.g.: type guard functions). +- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Libraries/Frameworks:** NEVER assume a library/framework is available. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', etc.) before employing it. - **Technical Integrity:** You are responsible for the entire lifecycle: implementation, testing, and validation. Within the scope of your changes, prioritize readability and long-term maintainability by consolidating logic into clean abstractions rather than threading state across unrelated layers. Align strictly with the requested architectural direction, ensuring the final implementation is focused and free of redundant "just-in-case" alternatives. Validation is not merely running tests; it is the exhaustive process of ensuring that every aspect of your change—behavioral, structural, and stylistic—is correct and fully compatible with the broader project. For bug fixes, you must empirically reproduce the failure with a new test case or reproduction script before applying the fix. - **Expertise & Intent Alignment:** Provide proactive technical opinions grounded in research while strictly adhering to the user's intended workflow. Distinguish between **Directives** (unambiguous requests for action or implementation) and **Inquiries** (requests for analysis, advice, or observations). Assume all requests are Inquiries unless they contain an explicit instruction to perform a task. For Inquiries, your scope is strictly limited to research and analysis; you may propose a solution or strategy, but you MUST NOT modify files until a corresponding Directive is issued. Do not initiate implementation based on observations of bugs or statements of fact. Once an Inquiry is resolved, or while waiting for a Directive, stop and wait for the next user instruction. For Directives, only clarify if critically underspecified; otherwise, work autonomously. You should only seek user intervention if you have exhausted all possible routes or if a proposed solution would take the workspace in a significantly different architectural direction. @@ -2089,7 +2108,8 @@ Use the following guidelines to optimize your search and read patterns. ## Engineering Standards - **Contextual Precedence:** Instructions found in \`GEMINI.md\` files are foundational mandates. They take absolute precedence over the general workflows and tool defaults described in this system prompt. - **Conventions & Style:** Rigorously adhere to existing workspace conventions, architectural patterns, and style (naming, formatting, typing, commenting). During the research phase, analyze surrounding files, tests, and configuration to ensure your changes are seamless, idiomatic, and consistent with the local context. Never compromise idiomatic quality or completeness (e.g., proper declarations, type safety, documentation) to minimize tool calls; all supporting changes required by local conventions are part of a surgical update. -- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings or bypassing the type system (i.e.: casts in TypeScript) unless explicitly instructed to by the user. Instead, use idiomatic language features (e.g.: type guard functions). +- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Libraries/Frameworks:** NEVER assume a library/framework is available. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', etc.) before employing it. - **Technical Integrity:** You are responsible for the entire lifecycle: implementation, testing, and validation. Within the scope of your changes, prioritize readability and long-term maintainability by consolidating logic into clean abstractions rather than threading state across unrelated layers. Align strictly with the requested architectural direction, ensuring the final implementation is focused and free of redundant "just-in-case" alternatives. Validation is not merely running tests; it is the exhaustive process of ensuring that every aspect of your change—behavioral, structural, and stylistic—is correct and fully compatible with the broader project. For bug fixes, you must empirically reproduce the failure with a new test case or reproduction script before applying the fix. - **Expertise & Intent Alignment:** Provide proactive technical opinions grounded in research while strictly adhering to the user's intended workflow. Distinguish between **Directives** (unambiguous requests for action or implementation) and **Inquiries** (requests for analysis, advice, or observations). Assume all requests are Inquiries unless they contain an explicit instruction to perform a task. For Inquiries, your scope is strictly limited to research and analysis; you may propose a solution or strategy, but you MUST NOT modify files until a corresponding Directive is issued. Do not initiate implementation based on observations of bugs or statements of fact. Once an Inquiry is resolved, or while waiting for a Directive, stop and wait for the next user instruction. For Directives, only clarify if critically underspecified; otherwise, work autonomously. You should only seek user intervention if you have exhausted all possible routes or if a proposed solution would take the workspace in a significantly different architectural direction. @@ -2247,7 +2267,8 @@ Use the following guidelines to optimize your search and read patterns. ## Engineering Standards - **Contextual Precedence:** Instructions found in \`GEMINI.md\` files are foundational mandates. They take absolute precedence over the general workflows and tool defaults described in this system prompt. - **Conventions & Style:** Rigorously adhere to existing workspace conventions, architectural patterns, and style (naming, formatting, typing, commenting). During the research phase, analyze surrounding files, tests, and configuration to ensure your changes are seamless, idiomatic, and consistent with the local context. Never compromise idiomatic quality or completeness (e.g., proper declarations, type safety, documentation) to minimize tool calls; all supporting changes required by local conventions are part of a surgical update. -- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings or bypassing the type system (i.e.: casts in TypeScript) unless explicitly instructed to by the user. Instead, use idiomatic language features (e.g.: type guard functions). +- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Libraries/Frameworks:** NEVER assume a library/framework is available. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', etc.) before employing it. - **Technical Integrity:** You are responsible for the entire lifecycle: implementation, testing, and validation. Within the scope of your changes, prioritize readability and long-term maintainability by consolidating logic into clean abstractions rather than threading state across unrelated layers. Align strictly with the requested architectural direction, ensuring the final implementation is focused and free of redundant "just-in-case" alternatives. Validation is not merely running tests; it is the exhaustive process of ensuring that every aspect of your change—behavioral, structural, and stylistic—is correct and fully compatible with the broader project. For bug fixes, you must empirically reproduce the failure with a new test case or reproduction script before applying the fix. - **Expertise & Intent Alignment:** Provide proactive technical opinions grounded in research while strictly adhering to the user's intended workflow. Distinguish between **Directives** (unambiguous requests for action or implementation) and **Inquiries** (requests for analysis, advice, or observations). Assume all requests are Inquiries unless they contain an explicit instruction to perform a task. For Inquiries, your scope is strictly limited to research and analysis; you may propose a solution or strategy, but you MUST NOT modify files until a corresponding Directive is issued. Do not initiate implementation based on observations of bugs or statements of fact. Once an Inquiry is resolved, or while waiting for a Directive, stop and wait for the next user instruction. For Directives, only clarify if critically underspecified; otherwise, work autonomously. You should only seek user intervention if you have exhausted all possible routes or if a proposed solution would take the workspace in a significantly different architectural direction. @@ -2405,7 +2426,8 @@ Use the following guidelines to optimize your search and read patterns. ## Engineering Standards - **Contextual Precedence:** Instructions found in \`GEMINI.md\` files are foundational mandates. They take absolute precedence over the general workflows and tool defaults described in this system prompt. - **Conventions & Style:** Rigorously adhere to existing workspace conventions, architectural patterns, and style (naming, formatting, typing, commenting). During the research phase, analyze surrounding files, tests, and configuration to ensure your changes are seamless, idiomatic, and consistent with the local context. Never compromise idiomatic quality or completeness (e.g., proper declarations, type safety, documentation) to minimize tool calls; all supporting changes required by local conventions are part of a surgical update. -- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings or bypassing the type system (i.e.: casts in TypeScript) unless explicitly instructed to by the user. Instead, use idiomatic language features (e.g.: type guard functions). +- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Libraries/Frameworks:** NEVER assume a library/framework is available. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', etc.) before employing it. - **Technical Integrity:** You are responsible for the entire lifecycle: implementation, testing, and validation. Within the scope of your changes, prioritize readability and long-term maintainability by consolidating logic into clean abstractions rather than threading state across unrelated layers. Align strictly with the requested architectural direction, ensuring the final implementation is focused and free of redundant "just-in-case" alternatives. Validation is not merely running tests; it is the exhaustive process of ensuring that every aspect of your change—behavioral, structural, and stylistic—is correct and fully compatible with the broader project. For bug fixes, you must empirically reproduce the failure with a new test case or reproduction script before applying the fix. - **Expertise & Intent Alignment:** Provide proactive technical opinions grounded in research while strictly adhering to the user's intended workflow. Distinguish between **Directives** (unambiguous requests for action or implementation) and **Inquiries** (requests for analysis, advice, or observations). Assume all requests are Inquiries unless they contain an explicit instruction to perform a task. For Inquiries, your scope is strictly limited to research and analysis; you may propose a solution or strategy, but you MUST NOT modify files until a corresponding Directive is issued. Do not initiate implementation based on observations of bugs or statements of fact. Once an Inquiry is resolved, or while waiting for a Directive, stop and wait for the next user instruction. For Directives, only clarify if critically underspecified; otherwise, work autonomously. You should only seek user intervention if you have exhausted all possible routes or if a proposed solution would take the workspace in a significantly different architectural direction. @@ -2557,7 +2579,8 @@ Use the following guidelines to optimize your search and read patterns. ## Engineering Standards - **Contextual Precedence:** Instructions found in \`GEMINI.md\` files are foundational mandates. They take absolute precedence over the general workflows and tool defaults described in this system prompt. - **Conventions & Style:** Rigorously adhere to existing workspace conventions, architectural patterns, and style (naming, formatting, typing, commenting). During the research phase, analyze surrounding files, tests, and configuration to ensure your changes are seamless, idiomatic, and consistent with the local context. Never compromise idiomatic quality or completeness (e.g., proper declarations, type safety, documentation) to minimize tool calls; all supporting changes required by local conventions are part of a surgical update. -- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings or bypassing the type system (i.e.: casts in TypeScript) unless explicitly instructed to by the user. Instead, use idiomatic language features (e.g.: type guard functions). +- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Libraries/Frameworks:** NEVER assume a library/framework is available. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', etc.) before employing it. - **Technical Integrity:** You are responsible for the entire lifecycle: implementation, testing, and validation. Within the scope of your changes, prioritize readability and long-term maintainability by consolidating logic into clean abstractions rather than threading state across unrelated layers. Align strictly with the requested architectural direction, ensuring the final implementation is focused and free of redundant "just-in-case" alternatives. Validation is not merely running tests; it is the exhaustive process of ensuring that every aspect of your change—behavioral, structural, and stylistic—is correct and fully compatible with the broader project. For bug fixes, you must empirically reproduce the failure with a new test case or reproduction script before applying the fix. - **Expertise & Intent Alignment:** Provide proactive technical opinions grounded in research while strictly adhering to the user's intended workflow. Distinguish between **Directives** (unambiguous requests for action or implementation) and **Inquiries** (requests for analysis, advice, or observations). Assume all requests are Inquiries unless they contain an explicit instruction to perform a task. For Inquiries, your scope is strictly limited to research and analysis; you may propose a solution or strategy, but you MUST NOT modify files until a corresponding Directive is issued. Do not initiate implementation based on observations of bugs or statements of fact. Once an Inquiry is resolved, or while waiting for a Directive, stop and wait for the next user instruction. For Directives, only clarify if critically underspecified; otherwise, work autonomously. You should only seek user intervention if you have exhausted all possible routes or if a proposed solution would take the workspace in a significantly different architectural direction. @@ -2714,7 +2737,8 @@ Use the following guidelines to optimize your search and read patterns. ## Engineering Standards - **Contextual Precedence:** Instructions found in \`GEMINI.md\` files are foundational mandates. They take absolute precedence over the general workflows and tool defaults described in this system prompt. - **Conventions & Style:** Rigorously adhere to existing workspace conventions, architectural patterns, and style (naming, formatting, typing, commenting). During the research phase, analyze surrounding files, tests, and configuration to ensure your changes are seamless, idiomatic, and consistent with the local context. Never compromise idiomatic quality or completeness (e.g., proper declarations, type safety, documentation) to minimize tool calls; all supporting changes required by local conventions are part of a surgical update. -- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings or bypassing the type system (i.e.: casts in TypeScript) unless explicitly instructed to by the user. Instead, use idiomatic language features (e.g.: type guard functions). +- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Libraries/Frameworks:** NEVER assume a library/framework is available. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', etc.) before employing it. - **Technical Integrity:** You are responsible for the entire lifecycle: implementation, testing, and validation. Within the scope of your changes, prioritize readability and long-term maintainability by consolidating logic into clean abstractions rather than threading state across unrelated layers. Align strictly with the requested architectural direction, ensuring the final implementation is focused and free of redundant "just-in-case" alternatives. Validation is not merely running tests; it is the exhaustive process of ensuring that every aspect of your change—behavioral, structural, and stylistic—is correct and fully compatible with the broader project. For bug fixes, you must empirically reproduce the failure with a new test case or reproduction script before applying the fix. - **Expertise & Intent Alignment:** Provide proactive technical opinions grounded in research while strictly adhering to the user's intended workflow. Distinguish between **Directives** (unambiguous requests for action or implementation) and **Inquiries** (requests for analysis, advice, or observations). Assume all requests are Inquiries unless they contain an explicit instruction to perform a task. For Inquiries, your scope is strictly limited to research and analysis; you may propose a solution or strategy, but you MUST NOT modify files until a corresponding Directive is issued. Do not initiate implementation based on observations of bugs or statements of fact. Once an Inquiry is resolved, or while waiting for a Directive, stop and wait for the next user instruction. For Directives, only clarify if critically underspecified; otherwise, work autonomously. You should only seek user intervention if you have exhausted all possible routes or if a proposed solution would take the workspace in a significantly different architectural direction. @@ -2839,6 +2863,8 @@ exports[`Core System Prompt (prompts.ts) > should include the TASK MANAGEMENT PR - **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', 'build.gradle', etc., or observe neighboring files) before employing it. - **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project. - **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically. +- **Types, Warnings & Linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Comments:** Add code comments sparingly. Focus on *why* something is done, especially for complex logic, rather than *what* is done. Only add high-value comments if necessary for clarity or if requested by the user. Do not edit comments that are separate from the code you are changing. *NEVER* talk to the user or describe your changes through comments. - **Proactiveness:** Fulfill the user's request thoroughly. When adding features or fixing bugs, this includes adding tests to ensure quality. Consider all created files, especially tests, to be permanent artifacts unless the user says otherwise. - **User Hints:** During execution, the user may provide real-time hints (marked as "User hint:" or "User hints:"). Treat these as high-priority but scope-preserving course corrections: apply the minimal plan change needed, keep unaffected user tasks active, and never cancel/skip tasks unless cancellation is explicit for those tasks. Hints may add new tasks, modify one or more tasks, cancel specific tasks, or provide extra context only. If scope is ambiguous, ask for clarification before dropping work. @@ -2997,7 +3023,8 @@ Use the following guidelines to optimize your search and read patterns. ## Engineering Standards - **Contextual Precedence:** Instructions found in \`GEMINI.md\` files are foundational mandates. They take absolute precedence over the general workflows and tool defaults described in this system prompt. - **Conventions & Style:** Rigorously adhere to existing workspace conventions, architectural patterns, and style (naming, formatting, typing, commenting). During the research phase, analyze surrounding files, tests, and configuration to ensure your changes are seamless, idiomatic, and consistent with the local context. Never compromise idiomatic quality or completeness (e.g., proper declarations, type safety, documentation) to minimize tool calls; all supporting changes required by local conventions are part of a surgical update. -- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings or bypassing the type system (i.e.: casts in TypeScript) unless explicitly instructed to by the user. Instead, use idiomatic language features (e.g.: type guard functions). +- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Libraries/Frameworks:** NEVER assume a library/framework is available. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', etc.) before employing it. - **Technical Integrity:** You are responsible for the entire lifecycle: implementation, testing, and validation. Within the scope of your changes, prioritize readability and long-term maintainability by consolidating logic into clean abstractions rather than threading state across unrelated layers. Align strictly with the requested architectural direction, ensuring the final implementation is focused and free of redundant "just-in-case" alternatives. Validation is not merely running tests; it is the exhaustive process of ensuring that every aspect of your change—behavioral, structural, and stylistic—is correct and fully compatible with the broader project. For bug fixes, you must empirically reproduce the failure with a new test case or reproduction script before applying the fix. - **Expertise & Intent Alignment:** Provide proactive technical opinions grounded in research while strictly adhering to the user's intended workflow. Distinguish between **Directives** (unambiguous requests for action or implementation) and **Inquiries** (requests for analysis, advice, or observations). Assume all requests are Inquiries unless they contain an explicit instruction to perform a task. For Inquiries, your scope is strictly limited to research and analysis; you may propose a solution or strategy, but you MUST NOT modify files until a corresponding Directive is issued. Do not initiate implementation based on observations of bugs or statements of fact. Once an Inquiry is resolved, or while waiting for a Directive, stop and wait for the next user instruction. For Directives, only clarify if critically underspecified; otherwise, work autonomously. You should only seek user intervention if you have exhausted all possible routes or if a proposed solution would take the workspace in a significantly different architectural direction. @@ -3134,6 +3161,8 @@ exports[`Core System Prompt (prompts.ts) > should match snapshot on Windows 1`] - **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', 'build.gradle', etc., or observe neighboring files) before employing it. - **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project. - **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically. +- **Types, Warnings & Linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Comments:** Add code comments sparingly. Focus on *why* something is done, especially for complex logic, rather than *what* is done. Only add high-value comments if necessary for clarity or if requested by the user. Do not edit comments that are separate from the code you are changing. *NEVER* talk to the user or describe your changes through comments. - **Proactiveness:** Fulfill the user's request thoroughly. When adding features or fixing bugs, this includes adding tests to ensure quality. Consider all created files, especially tests, to be permanent artifacts unless the user says otherwise. - **User Hints:** During execution, the user may provide real-time hints (marked as "User hint:" or "User hints:"). Treat these as high-priority but scope-preserving course corrections: apply the minimal plan change needed, keep unaffected user tasks active, and never cancel/skip tasks unless cancellation is explicit for those tasks. Hints may add new tasks, modify one or more tasks, cancel specific tasks, or provide extra context only. If scope is ambiguous, ask for clarification before dropping work. @@ -3247,6 +3276,8 @@ exports[`Core System Prompt (prompts.ts) > should render hierarchical memory wit - **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', 'build.gradle', etc., or observe neighboring files) before employing it. - **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project. - **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically. +- **Types, Warnings & Linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Comments:** Add code comments sparingly. Focus on *why* something is done, especially for complex logic, rather than *what* is done. Only add high-value comments if necessary for clarity or if requested by the user. Do not edit comments that are separate from the code you are changing. *NEVER* talk to the user or describe your changes through comments. - **Proactiveness:** Fulfill the user's request thoroughly. When adding features or fixing bugs, this includes adding tests to ensure quality. Consider all created files, especially tests, to be permanent artifacts unless the user says otherwise. - **Conflict Resolution:** Instructions are provided in hierarchical context tags: \`\`, \`\`, and \`\`. In case of contradictory instructions, follow this priority: \`\` (highest) > \`\` > \`\` (lowest). @@ -3408,7 +3439,8 @@ Use the following guidelines to optimize your search and read patterns. ## Engineering Standards - **Contextual Precedence:** Instructions found in \`GEMINI.md\` files are foundational mandates. They take absolute precedence over the general workflows and tool defaults described in this system prompt. - **Conventions & Style:** Rigorously adhere to existing workspace conventions, architectural patterns, and style (naming, formatting, typing, commenting). During the research phase, analyze surrounding files, tests, and configuration to ensure your changes are seamless, idiomatic, and consistent with the local context. Never compromise idiomatic quality or completeness (e.g., proper declarations, type safety, documentation) to minimize tool calls; all supporting changes required by local conventions are part of a surgical update. -- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings or bypassing the type system (i.e.: casts in TypeScript) unless explicitly instructed to by the user. Instead, use idiomatic language features (e.g.: type guard functions). +- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Libraries/Frameworks:** NEVER assume a library/framework is available. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', etc.) before employing it. - **Technical Integrity:** You are responsible for the entire lifecycle: implementation, testing, and validation. Within the scope of your changes, prioritize readability and long-term maintainability by consolidating logic into clean abstractions rather than threading state across unrelated layers. Align strictly with the requested architectural direction, ensuring the final implementation is focused and free of redundant "just-in-case" alternatives. Validation is not merely running tests; it is the exhaustive process of ensuring that every aspect of your change—behavioral, structural, and stylistic—is correct and fully compatible with the broader project. For bug fixes, you must empirically reproduce the failure with a new test case or reproduction script before applying the fix. - **Expertise & Intent Alignment:** Provide proactive technical opinions grounded in research while strictly adhering to the user's intended workflow. Distinguish between **Directives** (unambiguous requests for action or implementation) and **Inquiries** (requests for analysis, advice, or observations). Assume all requests are Inquiries unless they contain an explicit instruction to perform a task. For Inquiries, your scope is strictly limited to research and analysis; you may propose a solution or strategy, but you MUST NOT modify files until a corresponding Directive is issued. Do not initiate implementation based on observations of bugs or statements of fact. Once an Inquiry is resolved, or while waiting for a Directive, stop and wait for the next user instruction. For Directives, only clarify if critically underspecified; otherwise, work autonomously. You should only seek user intervention if you have exhausted all possible routes or if a proposed solution would take the workspace in a significantly different architectural direction. @@ -3566,7 +3598,8 @@ Use the following guidelines to optimize your search and read patterns. ## Engineering Standards - **Contextual Precedence:** Instructions found in \`GEMINI.md\` files are foundational mandates. They take absolute precedence over the general workflows and tool defaults described in this system prompt. - **Conventions & Style:** Rigorously adhere to existing workspace conventions, architectural patterns, and style (naming, formatting, typing, commenting). During the research phase, analyze surrounding files, tests, and configuration to ensure your changes are seamless, idiomatic, and consistent with the local context. Never compromise idiomatic quality or completeness (e.g., proper declarations, type safety, documentation) to minimize tool calls; all supporting changes required by local conventions are part of a surgical update. -- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings or bypassing the type system (i.e.: casts in TypeScript) unless explicitly instructed to by the user. Instead, use idiomatic language features (e.g.: type guard functions). +- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Libraries/Frameworks:** NEVER assume a library/framework is available. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', etc.) before employing it. - **Technical Integrity:** You are responsible for the entire lifecycle: implementation, testing, and validation. Within the scope of your changes, prioritize readability and long-term maintainability by consolidating logic into clean abstractions rather than threading state across unrelated layers. Align strictly with the requested architectural direction, ensuring the final implementation is focused and free of redundant "just-in-case" alternatives. Validation is not merely running tests; it is the exhaustive process of ensuring that every aspect of your change—behavioral, structural, and stylistic—is correct and fully compatible with the broader project. For bug fixes, you must empirically reproduce the failure with a new test case or reproduction script before applying the fix. - **Expertise & Intent Alignment:** Provide proactive technical opinions grounded in research while strictly adhering to the user's intended workflow. Distinguish between **Directives** (unambiguous requests for action or implementation) and **Inquiries** (requests for analysis, advice, or observations). Assume all requests are Inquiries unless they contain an explicit instruction to perform a task. For Inquiries, your scope is strictly limited to research and analysis; you may propose a solution or strategy, but you MUST NOT modify files until a corresponding Directive is issued. Do not initiate implementation based on observations of bugs or statements of fact. Once an Inquiry is resolved, or while waiting for a Directive, stop and wait for the next user instruction. For Directives, only clarify if critically underspecified; otherwise, work autonomously. You should only seek user intervention if you have exhausted all possible routes or if a proposed solution would take the workspace in a significantly different architectural direction. @@ -3691,6 +3724,8 @@ exports[`Core System Prompt (prompts.ts) > should return the interactive avoidan - **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', 'build.gradle', etc., or observe neighboring files) before employing it. - **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project. - **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically. +- **Types, Warnings & Linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Comments:** Add code comments sparingly. Focus on *why* something is done, especially for complex logic, rather than *what* is done. Only add high-value comments if necessary for clarity or if requested by the user. Do not edit comments that are separate from the code you are changing. *NEVER* talk to the user or describe your changes through comments. - **Proactiveness:** Fulfill the user's request thoroughly. When adding features or fixing bugs, this includes adding tests to ensure quality. Consider all created files, especially tests, to be permanent artifacts unless the user says otherwise. - **User Hints:** During execution, the user may provide real-time hints (marked as "User hint:" or "User hints:"). Treat these as high-priority but scope-preserving course corrections: apply the minimal plan change needed, keep unaffected user tasks active, and never cancel/skip tasks unless cancellation is explicit for those tasks. Hints may add new tasks, modify one or more tasks, cancel specific tasks, or provide extra context only. If scope is ambiguous, ask for clarification before dropping work. @@ -3836,7 +3871,8 @@ Use the following guidelines to optimize your search and read patterns. ## Engineering Standards - **Contextual Precedence:** Instructions found in \`GEMINI.md\` files are foundational mandates. They take absolute precedence over the general workflows and tool defaults described in this system prompt. - **Conventions & Style:** Rigorously adhere to existing workspace conventions, architectural patterns, and style (naming, formatting, typing, commenting). During the research phase, analyze surrounding files, tests, and configuration to ensure your changes are seamless, idiomatic, and consistent with the local context. Never compromise idiomatic quality or completeness (e.g., proper declarations, type safety, documentation) to minimize tool calls; all supporting changes required by local conventions are part of a surgical update. -- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings or bypassing the type system (i.e.: casts in TypeScript) unless explicitly instructed to by the user. Instead, use idiomatic language features (e.g.: type guard functions). +- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Libraries/Frameworks:** NEVER assume a library/framework is available. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', etc.) before employing it. - **Technical Integrity:** You are responsible for the entire lifecycle: implementation, testing, and validation. Within the scope of your changes, prioritize readability and long-term maintainability by consolidating logic into clean abstractions rather than threading state across unrelated layers. Align strictly with the requested architectural direction, ensuring the final implementation is focused and free of redundant "just-in-case" alternatives. Validation is not merely running tests; it is the exhaustive process of ensuring that every aspect of your change—behavioral, structural, and stylistic—is correct and fully compatible with the broader project. For bug fixes, you must empirically reproduce the failure with a new test case or reproduction script before applying the fix. - **Expertise & Intent Alignment:** Provide proactive technical opinions grounded in research while strictly adhering to the user's intended workflow. Distinguish between **Directives** (unambiguous requests for action or implementation) and **Inquiries** (requests for analysis, advice, or observations). Assume all requests are Inquiries unless they contain an explicit instruction to perform a task. For Inquiries, your scope is strictly limited to research and analysis; you may propose a solution or strategy, but you MUST NOT modify files until a corresponding Directive is issued. Do not initiate implementation based on observations of bugs or statements of fact. Once an Inquiry is resolved, or while waiting for a Directive, stop and wait for the next user instruction. For Directives, only clarify if critically underspecified; otherwise, work autonomously. You should only seek user intervention if you have exhausted all possible routes or if a proposed solution would take the workspace in a significantly different architectural direction. @@ -3994,7 +4030,8 @@ Use the following guidelines to optimize your search and read patterns. ## Engineering Standards - **Contextual Precedence:** Instructions found in \`GEMINI.md\` files are foundational mandates. They take absolute precedence over the general workflows and tool defaults described in this system prompt. - **Conventions & Style:** Rigorously adhere to existing workspace conventions, architectural patterns, and style (naming, formatting, typing, commenting). During the research phase, analyze surrounding files, tests, and configuration to ensure your changes are seamless, idiomatic, and consistent with the local context. Never compromise idiomatic quality or completeness (e.g., proper declarations, type safety, documentation) to minimize tool calls; all supporting changes required by local conventions are part of a surgical update. -- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings or bypassing the type system (i.e.: casts in TypeScript) unless explicitly instructed to by the user. Instead, use idiomatic language features (e.g.: type guard functions). +- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Libraries/Frameworks:** NEVER assume a library/framework is available. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', etc.) before employing it. - **Technical Integrity:** You are responsible for the entire lifecycle: implementation, testing, and validation. Within the scope of your changes, prioritize readability and long-term maintainability by consolidating logic into clean abstractions rather than threading state across unrelated layers. Align strictly with the requested architectural direction, ensuring the final implementation is focused and free of redundant "just-in-case" alternatives. Validation is not merely running tests; it is the exhaustive process of ensuring that every aspect of your change—behavioral, structural, and stylistic—is correct and fully compatible with the broader project. For bug fixes, you must empirically reproduce the failure with a new test case or reproduction script before applying the fix. - **Expertise & Intent Alignment:** Provide proactive technical opinions grounded in research while strictly adhering to the user's intended workflow. Distinguish between **Directives** (unambiguous requests for action or implementation) and **Inquiries** (requests for analysis, advice, or observations). Assume all requests are Inquiries unless they contain an explicit instruction to perform a task. For Inquiries, your scope is strictly limited to research and analysis; you may propose a solution or strategy, but you MUST NOT modify files until a corresponding Directive is issued. Do not initiate implementation based on observations of bugs or statements of fact. Once an Inquiry is resolved, or while waiting for a Directive, stop and wait for the next user instruction. For Directives, only clarify if critically underspecified; otherwise, work autonomously. You should only seek user intervention if you have exhausted all possible routes or if a proposed solution would take the workspace in a significantly different architectural direction. @@ -4119,6 +4156,8 @@ exports[`Core System Prompt (prompts.ts) > should use legacy system prompt for n - **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', 'build.gradle', etc., or observe neighboring files) before employing it. - **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project. - **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically. +- **Types, Warnings & Linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Comments:** Add code comments sparingly. Focus on *why* something is done, especially for complex logic, rather than *what* is done. Only add high-value comments if necessary for clarity or if requested by the user. Do not edit comments that are separate from the code you are changing. *NEVER* talk to the user or describe your changes through comments. - **Proactiveness:** Fulfill the user's request thoroughly. When adding features or fixing bugs, this includes adding tests to ensure quality. Consider all created files, especially tests, to be permanent artifacts unless the user says otherwise. - **User Hints:** During execution, the user may provide real-time hints (marked as "User hint:" or "User hints:"). Treat these as high-priority but scope-preserving course corrections: apply the minimal plan change needed, keep unaffected user tasks active, and never cancel/skip tasks unless cancellation is explicit for those tasks. Hints may add new tasks, modify one or more tasks, cancel specific tasks, or provide extra context only. If scope is ambiguous, ask for clarification before dropping work. diff --git a/packages/core/src/hooks/hookTranslator.test.ts b/packages/core/src/hooks/hookTranslator.test.ts index 785cadfc4e..8755049aa9 100644 --- a/packages/core/src/hooks/hookTranslator.test.ts +++ b/packages/core/src/hooks/hookTranslator.test.ts @@ -121,6 +121,56 @@ describe('HookTranslator', () => { }, ]); }); + + it('should apply model override when hook returns only model field', () => { + const baseRequest: GenerateContentParameters = { + model: 'gemini-2.5-flash-lite', + contents: [ + { + role: 'user', + parts: [{ text: 'Hello' }], + }, + ], + } as unknown as GenerateContentParameters; + + // Simulate a hook that only overrides the model — no messages field + const hookRequest = { + model: 'gemini-2.5-flash', + } as unknown as LLMRequest; + + const sdkRequest = translator.fromHookLLMRequest( + hookRequest, + baseRequest, + ); + + // Model should be overridden + expect(sdkRequest.model).toBe('gemini-2.5-flash'); + // Original conversation contents should be preserved + expect(sdkRequest.contents).toEqual(baseRequest.contents); + }); + + it('should preserve base request contents when hook messages is undefined', () => { + const baseRequest: GenerateContentParameters = { + model: 'gemini-1.5-flash', + contents: [ + { role: 'user', parts: [{ text: 'original message' }] }, + { role: 'model', parts: [{ text: 'original reply' }] }, + ], + } as unknown as GenerateContentParameters; + + const hookRequest = { + model: 'gemini-1.5-pro', + // messages intentionally omitted + } as unknown as LLMRequest; + + const sdkRequest = translator.fromHookLLMRequest( + hookRequest, + baseRequest, + ); + + expect(sdkRequest.model).toBe('gemini-1.5-pro'); + expect(sdkRequest.contents).toEqual(baseRequest.contents); + }); }); describe('LLM Response Translation', () => { diff --git a/packages/core/src/hooks/hookTranslator.ts b/packages/core/src/hooks/hookTranslator.ts index 82cd1a5850..a733168089 100644 --- a/packages/core/src/hooks/hookTranslator.ts +++ b/packages/core/src/hooks/hookTranslator.ts @@ -225,23 +225,30 @@ export class HookTranslatorGenAIv1 extends HookTranslator { hookRequest: LLMRequest, baseRequest?: GenerateContentParameters, ): GenerateContentParameters { - // Convert hook messages back to SDK Content format - const contents = hookRequest.messages.map((message) => ({ - role: message.role === 'model' ? 'model' : message.role, - parts: [ - { - text: - typeof message.content === 'string' - ? message.content - : String(message.content), - }, - ], - })); + // Convert hook messages back to SDK Content format. + // If the hook returned a partial request without messages (e.g. only + // overriding `model`), fall back to the base request's contents so the + // conversation is preserved. + const contents = hookRequest.messages + ? hookRequest.messages.map((message) => ({ + role: message.role === 'model' ? 'model' : message.role, + parts: [ + { + text: + typeof message.content === 'string' + ? message.content + : String(message.content), + }, + ], + })) + : (baseRequest?.contents ?? []); - // Build the result with proper typing + // Build the result with proper typing. + // Use nullish coalescing so a hook that only sets `model` still works -- + // fall back to the base request's model rather than overwriting with undefined. const result: GenerateContentParameters = { ...baseRequest, - model: hookRequest.model, + model: hookRequest.model ?? baseRequest?.model ?? '', contents, }; diff --git a/packages/core/src/policy/policies/plan.toml b/packages/core/src/policy/policies/plan.toml index e7a64e0748..80b59ba2d5 100644 --- a/packages/core/src/policy/policies/plan.toml +++ b/packages/core/src/policy/policies/plan.toml @@ -107,7 +107,8 @@ toolName = [ "activate_skill", "codebase_investigator", "cli_help", - "get_internal_docs" + "get_internal_docs", + "complete_task" ] decision = "allow" priority = 70 diff --git a/packages/core/src/policy/policies/sandbox-default.toml b/packages/core/src/policy/policies/sandbox-default.toml index 796902f0b4..6e2db3fd03 100644 --- a/packages/core/src/policy/policies/sandbox-default.toml +++ b/packages/core/src/policy/policies/sandbox-default.toml @@ -2,7 +2,7 @@ network = false readonly = true approvedTools = [] -allowOverrides = false +allowOverrides = true [modes.default] network = false @@ -17,4 +17,3 @@ approvedTools = ['sed', 'grep', 'awk', 'perl', 'cat', 'echo', 'Add-Content', 'Se allowOverrides = true [commands] - diff --git a/packages/core/src/policy/sandboxPolicyManager.test.ts b/packages/core/src/policy/sandboxPolicyManager.test.ts new file mode 100644 index 0000000000..034ab68735 --- /dev/null +++ b/packages/core/src/policy/sandboxPolicyManager.test.ts @@ -0,0 +1,72 @@ +/** + * @license + * Copyright 2026 Google LLC + * SPDX-License-Identifier: Apache-2.0 + */ + +import { describe, it, expect, beforeEach, afterEach } from 'vitest'; +import { SandboxPolicyManager } from './sandboxPolicyManager.js'; +import fs from 'node:fs'; +import os from 'node:os'; +import path from 'node:path'; + +describe('SandboxPolicyManager', () => { + const tempDir = path.join(os.tmpdir(), 'gemini-test-sandbox-policy'); + const configPath = path.join(tempDir, 'sandbox.toml'); + + beforeEach(() => { + if (!fs.existsSync(tempDir)) { + fs.mkdirSync(tempDir, { recursive: true }); + } + }); + + afterEach(() => { + if (fs.existsSync(tempDir)) { + fs.rmSync(tempDir, { recursive: true, force: true }); + } + }); + + it('should add and retrieve session approvals', () => { + const manager = new SandboxPolicyManager(configPath); + manager.addSessionApproval('ls', { + fileSystem: { read: ['/tmp'], write: [] }, + network: false, + }); + + const perms = manager.getCommandPermissions('ls'); + expect(perms.fileSystem?.read).toContain('/tmp'); + }); + + it('should protect against prototype pollution (session)', () => { + const manager = new SandboxPolicyManager(configPath); + manager.addSessionApproval('__proto__', { + fileSystem: { read: ['/POLLUTED'], write: [] }, + network: true, + }); + + const perms = manager.getCommandPermissions('any-command'); + expect(perms.fileSystem?.read).not.toContain('/POLLUTED'); + }); + + it('should protect against prototype pollution (persistent)', () => { + const manager = new SandboxPolicyManager(configPath); + manager.addPersistentApproval('constructor', { + fileSystem: { read: ['/POLLUTED_PERSISTENT'], write: [] }, + network: true, + }); + + const perms = manager.getCommandPermissions('constructor'); + expect(perms.fileSystem?.read).not.toContain('/POLLUTED_PERSISTENT'); + }); + + it('should lowercase command names for normalization', () => { + const manager = new SandboxPolicyManager(configPath); + manager.addSessionApproval('NPM', { + fileSystem: { read: ['/node_modules'], write: [] }, + network: true, + }); + + const perms = manager.getCommandPermissions('npm'); + expect(perms.fileSystem?.read).toContain('/node_modules'); + }); +}); diff --git a/packages/core/src/policy/sandboxPolicyManager.ts b/packages/core/src/policy/sandboxPolicyManager.ts index c8a4d2f8df..84b627eb92 100644 --- a/packages/core/src/policy/sandboxPolicyManager.ts +++ b/packages/core/src/policy/sandboxPolicyManager.ts @@ -13,6 +13,7 @@ import { fileURLToPath } from 'node:url'; import { debugLogger } from '../utils/debugLogger.js'; import { type SandboxPermissions } from '../services/sandboxManager.js'; import { sanitizePaths } from '../services/sandboxManager.js'; +import { normalizeCommand } from '../utils/shell-utils.js'; export const SandboxModeConfigSchema = z.object({ network: z.boolean(), @@ -63,7 +64,7 @@ export class SandboxPolicyManager { network: false, readonly: true, approvedTools: [], - allowOverrides: false, + allowOverrides: true, }, default: { network: false, @@ -104,6 +105,10 @@ export class SandboxPolicyManager { this.config = this.loadConfig(); } + private isProtectedKey(key: string): boolean { + return key === '__proto__' || key === 'constructor' || key === 'prototype'; + } + private loadConfig(): SandboxTomlSchemaType { if (!fs.existsSync(this.configPath)) { return SandboxPolicyManager.DEFAULT_CONFIG; @@ -154,8 +159,15 @@ export class SandboxPolicyManager { } getCommandPermissions(commandName: string): SandboxPermissions { - const persistent = this.config.commands[commandName]; - const session = this.sessionApprovals[commandName]; + const normalized = normalizeCommand(commandName); + if (this.isProtectedKey(normalized)) { + return { + fileSystem: { read: [], write: [] }, + network: false, + }; + } + const persistent = this.config.commands[normalized]; + const session = this.sessionApprovals[normalized]; return { fileSystem: { @@ -176,25 +188,25 @@ export class SandboxPolicyManager { commandName: string, permissions: SandboxPermissions, ): void { - const existing = this.sessionApprovals[commandName] || { + const normalized = normalizeCommand(commandName); + if (this.isProtectedKey(normalized)) { + return; + } + const existing = this.sessionApprovals[normalized] || { fileSystem: { read: [], write: [] }, network: false, }; - this.sessionApprovals[commandName] = { + this.sessionApprovals[normalized] = { fileSystem: { - read: Array.from( - new Set([ - ...(existing.fileSystem?.read ?? []), - ...(permissions.fileSystem?.read ?? []), - ]), - ), - write: Array.from( - new Set([ - ...(existing.fileSystem?.write ?? []), - ...(permissions.fileSystem?.write ?? []), - ]), - ), + read: sanitizePaths([ + ...(existing.fileSystem?.read ?? []), + ...(permissions.fileSystem?.read ?? []), + ]), + write: sanitizePaths([ + ...(existing.fileSystem?.write ?? []), + ...(permissions.fileSystem?.write ?? []), + ]), }, network: existing.network || permissions.network || false, }; @@ -204,7 +216,11 @@ export class SandboxPolicyManager { commandName: string, permissions: SandboxPermissions, ): void { - const existing = this.config.commands[commandName] || { + const normalized = normalizeCommand(commandName); + if (this.isProtectedKey(normalized)) { + return; + } + const existing = this.config.commands[normalized] || { allowed_paths: [], allow_network: false, }; @@ -216,7 +232,7 @@ export class SandboxPolicyManager { ]; const newPaths = new Set(sanitizePaths(newPathsArray)); - this.config.commands[commandName] = { + this.config.commands[normalized] = { allowed_paths: Array.from(newPaths), allow_network: existing.allow_network || permissions.network || false, }; diff --git a/packages/core/src/prompts/snippets.legacy.ts b/packages/core/src/prompts/snippets.legacy.ts index 4fea88937b..17380024c4 100644 --- a/packages/core/src/prompts/snippets.legacy.ts +++ b/packages/core/src/prompts/snippets.legacy.ts @@ -177,6 +177,8 @@ export function renderCoreMandates(options?: CoreMandatesOptions): string { - **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', 'build.gradle', etc., or observe neighboring files) before employing it. - **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project. - **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically. +- **Types, Warnings & Linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Comments:** Add code comments sparingly. Focus on *why* something is done, especially for complex logic, rather than *what* is done. Only add high-value comments if necessary for clarity or if requested by the user. Do not edit comments that are separate from the code you are changing. *NEVER* talk to the user or describe your changes through comments. - **Proactiveness:** Fulfill the user's request thoroughly. When adding features or fixing bugs, this includes adding tests to ensure quality. Consider all created files, especially tests, to be permanent artifacts unless the user says otherwise.${mandateConflictResolution(options.hasHierarchicalMemory)} - **User Hints:** During execution, the user may provide real-time hints (marked as "User hint:" or "User hints:"). Treat these as high-priority but scope-preserving course corrections: apply the minimal plan change needed, keep unaffected user tasks active, and never cancel/skip tasks unless cancellation is explicit for those tasks. Hints may add new tasks, modify one or more tasks, cancel specific tasks, or provide extra context only. If scope is ambiguous, ask for clarification before dropping work. @@ -518,10 +520,12 @@ function mandateTopicUpdateModel(): string { ## Topic Updates As you work, the user follows along by reading topic updates that you publish with ${UPDATE_TOPIC_TOOL_NAME}. Keep them informed by doing the following: -- Always call ${UPDATE_TOPIC_TOOL_NAME} in your first and last turn. The final turn should always recap what was done. +- Usage Exception: NEVER use ${UPDATE_TOPIC_TOOL_NAME} for answering questions, providing explanations, or performing isolated lookup tasks (e.g. reading a single file, running a quick search, or checking a version). It is STRICTLY for orchestrating multi-step codebase modifications or complex investigations involving 3 or more tool calls. +- Always call ${UPDATE_TOPIC_TOOL_NAME} in your first turn. +- For tasks taking multiple turns, also call ${UPDATE_TOPIC_TOOL_NAME} in your last turn to recap what was done. - Each topic update should give a concise description of what you are doing for the next few turns in the \`${TOPIC_PARAM_SUMMARY}\` parameter. - Provide topic updates whenever you change "topics". A topic is typically a discrete subgoal and will be every 3 to 10 turns. Do not use ${UPDATE_TOPIC_TOOL_NAME} on every turn. -- The typical user message should call ${UPDATE_TOPIC_TOOL_NAME} 3 or more times. Each corresponds to a distinct phase of the task, such as "Researching X", "Researching Y", "Implementing Z with X", and "Testing Z". +- The typical complex user message should call ${UPDATE_TOPIC_TOOL_NAME} 3 or more times. Each corresponds to a distinct phase of the task, such as "Researching X", "Researching Y", "Implementing Z with X", and "Testing Z". - Remember to call ${UPDATE_TOPIC_TOOL_NAME} when you experience an unexpected event (e.g., a test failure, compilation error, environment issue, or unexpected learning) that requires a strategic detour. - **Examples:** - ${UPDATE_TOPIC_TOOL_NAME}(${TOPIC_PARAM_TITLE}="Researching Parser", ${TOPIC_PARAM_SUMMARY}="I am starting an investigation into the parser timeout bug. My goal is to first understand the current test coverage and then attempt to reproduce the failure. This phase will focus on identifying the bottleneck in the main loop before we move to implementation.") diff --git a/packages/core/src/prompts/snippets.ts b/packages/core/src/prompts/snippets.ts index 5440583419..59315e1ca6 100644 --- a/packages/core/src/prompts/snippets.ts +++ b/packages/core/src/prompts/snippets.ts @@ -229,7 +229,8 @@ Use the following guidelines to optimize your search and read patterns. ## Engineering Standards - **Contextual Precedence:** Instructions found in ${formattedFilenames} files are foundational mandates. They take absolute precedence over the general workflows and tool defaults described in this system prompt. - **Conventions & Style:** Rigorously adhere to existing workspace conventions, architectural patterns, and style (naming, formatting, typing, commenting). During the research phase, analyze surrounding files, tests, and configuration to ensure your changes are seamless, idiomatic, and consistent with the local context. Never compromise idiomatic quality or completeness (e.g., proper declarations, type safety, documentation) to minimize tool calls; all supporting changes required by local conventions are part of a surgical update. -- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings or bypassing the type system (i.e.: casts in TypeScript) unless explicitly instructed to by the user. Instead, use idiomatic language features (e.g.: type guard functions). +- **Types, warnings and linters:** NEVER use hacks like disabling or suppressing warnings, bypassing the type system (e.g.: casts in TypeScript), or employing "hidden" logic (e.g.: reflection, prototype manipulation) unless explicitly instructed to by the user. Instead, use explicit and idiomatic language features (e.g.: type guards, explicit class instantiation, or object spread) that maintain structural integrity and type safety. +- **Design Patterns:** Prioritize explicit composition and delegation (e.g.: wrapper classes, proxies, or factory functions) over complex inheritance or prototype-based cloning. When extending or modifying existing classes, prefer patterns that are easily traceable and type-safe. - **Libraries/Frameworks:** NEVER assume a library/framework is available. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', etc.) before employing it. - **Technical Integrity:** You are responsible for the entire lifecycle: implementation, testing, and validation. Within the scope of your changes, prioritize readability and long-term maintainability by consolidating logic into clean abstractions rather than threading state across unrelated layers. Align strictly with the requested architectural direction, ensuring the final implementation is focused and free of redundant "just-in-case" alternatives. Validation is not merely running tests; it is the exhaustive process of ensuring that every aspect of your change—behavioral, structural, and stylistic—is correct and fully compatible with the broader project. For bug fixes, you must empirically reproduce the failure with a new test case or reproduction script before applying the fix. - **Expertise & Intent Alignment:** Provide proactive technical opinions grounded in research while strictly adhering to the user's intended workflow. Distinguish between **Directives** (unambiguous requests for action or implementation) and **Inquiries** (requests for analysis, advice, or observations). Assume all requests are Inquiries unless they contain an explicit instruction to perform a task. For Inquiries, your scope is strictly limited to research and analysis; you may propose a solution or strategy, but you MUST NOT modify files until a corresponding Directive is issued. Do not initiate implementation based on observations of bugs or statements of fact. Once an Inquiry is resolved, or while waiting for a Directive, stop and wait for the next user instruction. ${options.interactive ? 'For Directives, only clarify if critically underspecified; otherwise, work autonomously.' : 'For Directives, you must work autonomously as no further user input is available.'} You should only seek user intervention if you have exhausted all possible routes or if a proposed solution would take the workspace in a significantly different architectural direction. @@ -629,10 +630,12 @@ function mandateTopicUpdateModel(): string { ## Topic Updates As you work, the user follows along by reading topic updates that you publish with ${UPDATE_TOPIC_TOOL_NAME}. Keep them informed by doing the following: -- Always call ${UPDATE_TOPIC_TOOL_NAME} in your first and last turn. The final turn should always recap what was done. +- Usage Exception: NEVER use ${UPDATE_TOPIC_TOOL_NAME} for answering questions, providing explanations, or performing isolated lookup tasks (e.g. reading a single file, running a quick search, or checking a version). It is STRICTLY for orchestrating multi-step codebase modifications or complex investigations involving 3 or more tool calls. +- Always call ${UPDATE_TOPIC_TOOL_NAME} in your first turn. +- For tasks taking multiple turns, also call ${UPDATE_TOPIC_TOOL_NAME} in your last turn to recap what was done. - Each topic update should give a concise description of what you are doing for the next few turns in the \`${TOPIC_PARAM_SUMMARY}\` parameter. - Provide topic updates whenever you change "topics". A topic is typically a discrete subgoal and will be every 3 to 10 turns. Do not use ${UPDATE_TOPIC_TOOL_NAME} on every turn. -- The typical user message should call ${UPDATE_TOPIC_TOOL_NAME} 3 or more times. Each corresponds to a distinct phase of the task, such as "Researching X", "Researching Y", "Implementing Z with X", and "Testing Z". +- The typical complex user message should call ${UPDATE_TOPIC_TOOL_NAME} 3 or more times. Each corresponds to a distinct phase of the task, such as "Researching X", "Researching Y", "Implementing Z with X", and "Testing Z". - Remember to call ${UPDATE_TOPIC_TOOL_NAME} when you experience an unexpected event (e.g., a test failure, compilation error, environment issue, or unexpected learning) that requires a strategic detour. - **Examples:** - \`update_topic(${TOPIC_PARAM_TITLE}="Researching Parser", ${TOPIC_PARAM_SUMMARY}="I am starting an investigation into the parser timeout bug. My goal is to first understand the current test coverage and then attempt to reproduce the failure. This phase will focus on identifying the bottleneck in the main loop before we move to implementation.")\` diff --git a/packages/core/src/sandbox/linux/LinuxSandboxManager.ts b/packages/core/src/sandbox/linux/LinuxSandboxManager.ts index d91ab1a836..000fea510f 100644 --- a/packages/core/src/sandbox/linux/LinuxSandboxManager.ts +++ b/packages/core/src/sandbox/linux/LinuxSandboxManager.ts @@ -148,6 +148,10 @@ export class LinuxSandboxManager implements SandboxManager { return this.options.workspace; } + getOptions(): GlobalSandboxOptions { + return this.options; + } + private getMaskFilePath(): string { if ( LinuxSandboxManager.maskFilePath && diff --git a/packages/core/src/sandbox/macos/MacOsSandboxManager.ts b/packages/core/src/sandbox/macos/MacOsSandboxManager.ts index 497bf30c31..0fee35110a 100644 --- a/packages/core/src/sandbox/macos/MacOsSandboxManager.ts +++ b/packages/core/src/sandbox/macos/MacOsSandboxManager.ts @@ -59,6 +59,10 @@ export class MacOsSandboxManager implements SandboxManager { return this.options.workspace; } + getOptions(): GlobalSandboxOptions { + return this.options; + } + async prepareCommand(req: SandboxRequest): Promise { await initializeShellParsers(); const sanitizationConfig = getSecureSanitizationConfig( diff --git a/packages/core/src/sandbox/utils/proactivePermissions.ts b/packages/core/src/sandbox/utils/proactivePermissions.ts index a5e11e2c3c..c4ec0c1520 100644 --- a/packages/core/src/sandbox/utils/proactivePermissions.ts +++ b/packages/core/src/sandbox/utils/proactivePermissions.ts @@ -8,6 +8,7 @@ import os from 'node:os'; import path from 'node:path'; import fs from 'node:fs'; import { type SandboxPermissions } from '../../services/sandboxManager.js'; +import { normalizeCommand } from '../../utils/shell-utils.js'; const NETWORK_RELIANT_TOOLS = new Set([ 'npm', @@ -45,7 +46,7 @@ export function isNetworkReliantCommand( commandName: string, subCommand?: string, ): boolean { - const normalizedCommand = commandName.toLowerCase().replace(/\.exe$/, ''); + const normalizedCommand = normalizeCommand(commandName); if (!NETWORK_RELIANT_TOOLS.has(normalizedCommand)) { return false; } @@ -82,7 +83,7 @@ export function isNetworkReliantCommand( export async function getProactiveToolSuggestions( commandName: string, ): Promise { - const normalizedCommand = commandName.toLowerCase().replace(/\.exe$/, ''); + const normalizedCommand = normalizeCommand(commandName); if (!NETWORK_RELIANT_TOOLS.has(normalizedCommand)) { return undefined; } diff --git a/packages/core/src/sandbox/windows/GeminiSandbox.cs b/packages/core/src/sandbox/windows/GeminiSandbox.cs index 6275b701c4..eef08b250b 100644 --- a/packages/core/src/sandbox/windows/GeminiSandbox.cs +++ b/packages/core/src/sandbox/windows/GeminiSandbox.cs @@ -21,6 +21,8 @@ using System.Text; */ public class GeminiSandbox { // P/Invoke constants and structures + private const int JobObjectExtendedLimitInformation = 9; + private const int JobObjectNetRateControlInformation = 32; private const uint JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 0x00002000; private const uint JOB_OBJECT_LIMIT_DIE_ON_UNHANDLED_EXCEPTION = 0x00000400; private const uint JOB_OBJECT_LIMIT_ACTIVE_PROCESS = 0x00000008; @@ -74,6 +76,9 @@ public class GeminiSandbox { [DllImport("kernel32.dll", SetLastError = true)] static extern bool AssignProcessToJobObject(IntPtr hJob, IntPtr hProcess); + [DllImport("kernel32.dll", SetLastError = true)] + static extern uint ResumeThread(IntPtr hThread); + [DllImport("advapi32.dll", SetLastError = true)] static extern bool OpenProcessToken(IntPtr ProcessHandle, uint DesiredAccess, out IntPtr TokenHandle); @@ -191,7 +196,8 @@ public class GeminiSandbox { IntPtr hToken = IntPtr.Zero; IntPtr hRestrictedToken = IntPtr.Zero; - IntPtr lowIntegritySid = IntPtr.Zero; + IntPtr hJob = IntPtr.Zero; + PROCESS_INFORMATION pi = new PROCESS_INFORMATION(); try { // 1. Duplicate Primary Token @@ -208,6 +214,7 @@ public class GeminiSandbox { // 2. Lower Integrity Level to Low // S-1-16-4096 is the SID for "Low Mandatory Level" + IntPtr lowIntegritySid = IntPtr.Zero; if (ConvertStringSidToSid("S-1-16-4096", out lowIntegritySid)) { TOKEN_MANDATORY_LABEL tml = new TOKEN_MANDATORY_LABEL(); tml.Label.Sid = lowIntegritySid; @@ -226,25 +233,42 @@ public class GeminiSandbox { } // 3. Setup Job Object for cleanup - IntPtr hJob = CreateJobObject(IntPtr.Zero, null); + hJob = CreateJobObject(IntPtr.Zero, null); + if (hJob == IntPtr.Zero) { + Console.Error.WriteLine("Error: CreateJobObject failed (" + Marshal.GetLastWin32Error() + ")"); + return 1; + } + JOBOBJECT_EXTENDED_LIMIT_INFORMATION jobLimits = new JOBOBJECT_EXTENDED_LIMIT_INFORMATION(); jobLimits.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE | JOB_OBJECT_LIMIT_DIE_ON_UNHANDLED_EXCEPTION; - + IntPtr lpJobLimits = Marshal.AllocHGlobal(Marshal.SizeOf(jobLimits)); - Marshal.StructureToPtr(jobLimits, lpJobLimits, false); - SetInformationJobObject(hJob, 9 /* JobObjectExtendedLimitInformation */, lpJobLimits, (uint)Marshal.SizeOf(jobLimits)); - Marshal.FreeHGlobal(lpJobLimits); + try { + Marshal.StructureToPtr(jobLimits, lpJobLimits, false); + if (!SetInformationJobObject(hJob, JobObjectExtendedLimitInformation, lpJobLimits, (uint)Marshal.SizeOf(jobLimits))) { + Console.Error.WriteLine("Error: SetInformationJobObject(Limits) failed (" + Marshal.GetLastWin32Error() + ")"); + return 1; + } + } finally { + Marshal.FreeHGlobal(lpJobLimits); + } if (!networkAccess) { JOBOBJECT_NET_RATE_CONTROL_INFORMATION netLimits = new JOBOBJECT_NET_RATE_CONTROL_INFORMATION(); netLimits.MaxBandwidth = 1; netLimits.ControlFlags = 0x1 | 0x2; // ENABLE | MAX_BANDWIDTH netLimits.DscpTag = 0; - + IntPtr lpNetLimits = Marshal.AllocHGlobal(Marshal.SizeOf(netLimits)); - Marshal.StructureToPtr(netLimits, lpNetLimits, false); - SetInformationJobObject(hJob, 32 /* JobObjectNetRateControlInformation */, lpNetLimits, (uint)Marshal.SizeOf(netLimits)); - Marshal.FreeHGlobal(lpNetLimits); + try { + Marshal.StructureToPtr(netLimits, lpNetLimits, false); + if (!SetInformationJobObject(hJob, JobObjectNetRateControlInformation, lpNetLimits, (uint)Marshal.SizeOf(netLimits))) { + // Some versions of Windows might not support network rate control, but we should know if it fails. + Console.Error.WriteLine("Warning: SetInformationJobObject(NetRate) failed (" + Marshal.GetLastWin32Error() + "). Network might not be throttled."); + } + } finally { + Marshal.FreeHGlobal(lpNetLimits); + } } // 4. Handle Internal Commands or External Process @@ -310,32 +334,49 @@ public class GeminiSandbox { commandLine += QuoteArgument(args[i]); } - PROCESS_INFORMATION pi = new PROCESS_INFORMATION(); - // Creation Flags: 0x04000000 (CREATE_BREAKAWAY_FROM_JOB) to allow job assignment if parent is in job - uint creationFlags = 0; + // Creation Flags: 0x01000000 (CREATE_BREAKAWAY_FROM_JOB) to allow job assignment if parent is in job + // 0x00000004 (CREATE_SUSPENDED) to prevent the process from executing before being placed in the job + uint creationFlags = 0x01000000 | 0x00000004; if (!CreateProcessAsUser(hRestrictedToken, null, commandLine, IntPtr.Zero, IntPtr.Zero, true, creationFlags, IntPtr.Zero, cwd, ref si, out pi)) { - Console.WriteLine("Error: CreateProcessAsUser failed (" + Marshal.GetLastWin32Error() + ") Command: " + commandLine); + int err = Marshal.GetLastWin32Error(); + Console.Error.WriteLine("Error: CreateProcessAsUser failed (" + err + ") Command: " + commandLine); return 1; } - AssignProcessToJobObject(hJob, pi.hProcess); - - // Wait for exit - uint waitResult = WaitForSingleObject(pi.hProcess, 0xFFFFFFFF); - uint exitCode = 0; - GetExitCodeProcess(pi.hProcess, out exitCode); + if (!AssignProcessToJobObject(hJob, pi.hProcess)) { + int err = Marshal.GetLastWin32Error(); + Console.Error.WriteLine("Error: AssignProcessToJobObject failed (" + err + ") Command: " + commandLine); + TerminateProcess(pi.hProcess, 1); + return 1; + } - CloseHandle(pi.hProcess); - CloseHandle(pi.hThread); - CloseHandle(hJob); + ResumeThread(pi.hThread); + + if (WaitForSingleObject(pi.hProcess, 0xFFFFFFFF) == 0xFFFFFFFF) { + int err = Marshal.GetLastWin32Error(); + Console.Error.WriteLine("Error: WaitForSingleObject failed (" + err + ")"); + } + + uint exitCode = 0; + if (!GetExitCodeProcess(pi.hProcess, out exitCode)) { + int err = Marshal.GetLastWin32Error(); + Console.Error.WriteLine("Error: GetExitCodeProcess failed (" + err + ")"); + return 1; + } return (int)exitCode; } finally { if (hToken != IntPtr.Zero) CloseHandle(hToken); if (hRestrictedToken != IntPtr.Zero) CloseHandle(hRestrictedToken); + if (hJob != IntPtr.Zero) CloseHandle(hJob); + if (pi.hProcess != IntPtr.Zero) CloseHandle(pi.hProcess); + if (pi.hThread != IntPtr.Zero) CloseHandle(pi.hThread); } } + [DllImport("kernel32.dll", SetLastError = true)] + static extern bool TerminateProcess(IntPtr hProcess, uint uExitCode); + [DllImport("kernel32.dll", SetLastError = true)] static extern uint WaitForSingleObject(IntPtr hHandle, uint dwMilliseconds); diff --git a/packages/core/src/sandbox/windows/WindowsSandboxManager.test.ts b/packages/core/src/sandbox/windows/WindowsSandboxManager.test.ts index 8b38179177..c814f740f7 100644 --- a/packages/core/src/sandbox/windows/WindowsSandboxManager.test.ts +++ b/packages/core/src/sandbox/windows/WindowsSandboxManager.test.ts @@ -25,17 +25,40 @@ vi.mock('../../utils/shell-utils.js', async (importOriginal) => { }; }); -// TODO: reenable once test is fixed -describe.skipIf(os.platform() === 'win32')('WindowsSandboxManager', () => { +describe('WindowsSandboxManager', () => { let manager: WindowsSandboxManager; let testCwd: string; + /** + * Creates a temporary directory and returns its canonical real path. + */ + function createTempDir(name: string, parent = os.tmpdir()): string { + const rawPath = fs.mkdtempSync(path.join(parent, `gemini-test-${name}-`)); + return fs.realpathSync(rawPath); + } + + const helperExePath = path.resolve( + __dirname, + WindowsSandboxManager.HELPER_EXE, + ); + beforeEach(() => { vi.spyOn(os, 'platform').mockReturnValue('win32'); vi.spyOn(sandboxManager, 'tryRealpath').mockImplementation(async (p) => p.toString(), ); - testCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'gemini-cli-test-')); + + // Mock existsSync to skip the csc.exe auto-compilation of helper during unit tests. + const originalExistsSync = fs.existsSync; + vi.spyOn(fs, 'existsSync').mockImplementation((p) => { + if (typeof p === 'string' && path.resolve(p) === helperExePath) { + return true; + } + return originalExistsSync(p); + }); + + testCwd = createTempDir('cwd'); + manager = new WindowsSandboxManager({ workspace: testCwd, modeConfig: { readonly: false, allowOverrides: true }, @@ -45,7 +68,9 @@ describe.skipIf(os.platform() === 'win32')('WindowsSandboxManager', () => { afterEach(() => { vi.restoreAllMocks(); - fs.rmSync(testCwd, { recursive: true, force: true }); + if (testCwd && fs.existsSync(testCwd)) { + fs.rmSync(testCwd, { recursive: true, force: true }); + } }); it('should prepare a GeminiSandbox.exe command', async () => { @@ -155,8 +180,7 @@ describe.skipIf(os.platform() === 'win32')('WindowsSandboxManager', () => { }); it('should handle persistent permissions from policyManager', async () => { - const persistentPath = path.join(testCwd, 'persistent_path'); - fs.mkdirSync(persistentPath, { recursive: true }); + const persistentPath = createTempDir('persistent', testCwd); const mockPolicyManager = { getCommandPermissions: vi.fn().mockReturnValue({ @@ -189,6 +213,8 @@ describe.skipIf(os.platform() === 'win32')('WindowsSandboxManager', () => { expect(icaclsArgs).toContainEqual([ persistentPath, + '/grant', + '*S-1-16-4096:(OI)(CI)(M)', '/setintegritylevel', '(OI)(CI)Low', ]); @@ -234,10 +260,7 @@ describe.skipIf(os.platform() === 'win32')('WindowsSandboxManager', () => { }); it('should grant Low Integrity access to the workspace and allowed paths', async () => { - const allowedPath = path.join(os.tmpdir(), 'gemini-cli-test-allowed'); - if (!fs.existsSync(allowedPath)) { - fs.mkdirSync(allowedPath); - } + const allowedPath = createTempDir('allowed'); try { const req: SandboxRequest = { command: 'test', @@ -257,13 +280,17 @@ describe.skipIf(os.platform() === 'win32')('WindowsSandboxManager', () => { .map((c) => c[1]); expect(icaclsArgs).toContainEqual([ - path.resolve(testCwd), + testCwd, + '/grant', + '*S-1-16-4096:(OI)(CI)(M)', '/setintegritylevel', '(OI)(CI)Low', ]); expect(icaclsArgs).toContainEqual([ - path.resolve(allowedPath), + allowedPath, + '/grant', + '*S-1-16-4096:(OI)(CI)(M)', '/setintegritylevel', '(OI)(CI)Low', ]); @@ -273,13 +300,7 @@ describe.skipIf(os.platform() === 'win32')('WindowsSandboxManager', () => { }); it('should grant Low Integrity access to additional write paths', async () => { - const extraWritePath = path.join( - os.tmpdir(), - 'gemini-cli-test-extra-write', - ); - if (!fs.existsSync(extraWritePath)) { - fs.mkdirSync(extraWritePath); - } + const extraWritePath = createTempDir('extra-write'); try { const req: SandboxRequest = { command: 'test', @@ -303,7 +324,9 @@ describe.skipIf(os.platform() === 'win32')('WindowsSandboxManager', () => { .map((c) => c[1]); expect(icaclsArgs).toContainEqual([ - path.resolve(extraWritePath), + extraWritePath, + '/grant', + '*S-1-16-4096:(OI)(CI)(M)', '/setintegritylevel', '(OI)(CI)Low', ]); @@ -330,26 +353,26 @@ describe.skipIf(os.platform() === 'win32')('WindowsSandboxManager', () => { }, }; - await manager.prepareCommand(req); + // Rejected because it's an unreachable/invalid UNC path or it doesn't exist + await expect(manager.prepareCommand(req)).rejects.toThrow(); const icaclsArgs = vi .mocked(spawnAsync) .mock.calls.filter((c) => c[0] === 'icacls') .map((c) => c[1]); - expect(icaclsArgs).not.toContainEqual([ - uncPath, - '/setintegritylevel', - '(OI)(CI)Low', - ]); + expect(icaclsArgs).not.toContainEqual(expect.arrayContaining([uncPath])); }, ); it.runIf(process.platform === 'win32')( 'should allow extended-length and local device paths', async () => { - const longPath = '\\\\?\\C:\\very\\long\\path'; - const devicePath = '\\\\.\\PhysicalDrive0'; + // Create actual files for inheritance/existence checks + const longPath = path.join(testCwd, 'very_long_path.txt'); + const devicePath = path.join(testCwd, 'device_path.txt'); + fs.writeFileSync(longPath, ''); + fs.writeFileSync(devicePath, ''); const req: SandboxRequest = { command: 'test', @@ -373,12 +396,16 @@ describe.skipIf(os.platform() === 'win32')('WindowsSandboxManager', () => { .map((c) => c[1]); expect(icaclsArgs).toContainEqual([ - longPath, + path.resolve(longPath), + '/grant', + '*S-1-16-4096:(OI)(CI)(M)', '/setintegritylevel', '(OI)(CI)Low', ]); expect(icaclsArgs).toContainEqual([ - devicePath, + path.resolve(devicePath), + '/grant', + '*S-1-16-4096:(OI)(CI)(M)', '/setintegritylevel', '(OI)(CI)Low', ]); @@ -420,10 +447,7 @@ describe.skipIf(os.platform() === 'win32')('WindowsSandboxManager', () => { }); it('should deny Low Integrity access to forbidden paths', async () => { - const forbiddenPath = path.join(os.tmpdir(), 'gemini-cli-test-forbidden'); - if (!fs.existsSync(forbiddenPath)) { - fs.mkdirSync(forbiddenPath); - } + const forbiddenPath = createTempDir('forbidden'); try { const managerWithForbidden = new WindowsSandboxManager({ workspace: testCwd, @@ -440,7 +464,7 @@ describe.skipIf(os.platform() === 'win32')('WindowsSandboxManager', () => { await managerWithForbidden.prepareCommand(req); expect(spawnAsync).toHaveBeenCalledWith('icacls', [ - path.resolve(forbiddenPath), + forbiddenPath, '/deny', '*S-1-16-4096:(OI)(CI)(F)', ]); @@ -450,10 +474,7 @@ describe.skipIf(os.platform() === 'win32')('WindowsSandboxManager', () => { }); it('should override allowed paths if a path is also in forbidden paths', async () => { - const conflictPath = path.join(os.tmpdir(), 'gemini-cli-test-conflict'); - if (!fs.existsSync(conflictPath)) { - fs.mkdirSync(conflictPath); - } + const conflictPath = createTempDir('conflict'); try { const managerWithForbidden = new WindowsSandboxManager({ workspace: testCwd, @@ -478,14 +499,14 @@ describe.skipIf(os.platform() === 'win32')('WindowsSandboxManager', () => { call[1] && call[1].includes('/setintegritylevel') && call[0] === 'icacls' && - call[1][0] === path.resolve(conflictPath), + call[1][0] === conflictPath, ); const denyCallIndex = spawnMock.mock.calls.findIndex( (call) => call[1] && call[1].includes('/deny') && call[0] === 'icacls' && - call[1][0] === path.resolve(conflictPath), + call[1][0] === conflictPath, ); // Conflict should have been filtered out of allow calls @@ -513,8 +534,8 @@ describe.skipIf(os.platform() === 'win32')('WindowsSandboxManager', () => { expect(result.args[5]).toBe(filePath); }); - it('should safely handle special characters in __write path', async () => { - const maliciousPath = path.join(testCwd, 'foo"; echo bar; ".txt'); + it('should safely handle special characters in __write path using environment variables', async () => { + const maliciousPath = path.join(testCwd, 'foo & echo bar; ! .txt'); fs.writeFileSync(maliciousPath, ''); const req: SandboxRequest = { command: '__write', @@ -545,4 +566,23 @@ describe.skipIf(os.platform() === 'win32')('WindowsSandboxManager', () => { expect(result.args[4]).toBe('__read'); expect(result.args[5]).toBe(filePath); }); + + it('should return a cleanup function that deletes the temporary manifest', async () => { + const req: SandboxRequest = { + command: 'test', + args: [], + cwd: testCwd, + env: {}, + }; + + const result = await manager.prepareCommand(req); + const manifestPath = result.args[3]; + + expect(fs.existsSync(manifestPath)).toBe(true); + expect(result.cleanup).toBeDefined(); + + result.cleanup?.(); + expect(fs.existsSync(manifestPath)).toBe(false); + expect(fs.existsSync(path.dirname(manifestPath))).toBe(false); + }); }); diff --git a/packages/core/src/sandbox/windows/WindowsSandboxManager.ts b/packages/core/src/sandbox/windows/WindowsSandboxManager.ts index 3328c2b918..943a339960 100644 --- a/packages/core/src/sandbox/windows/WindowsSandboxManager.ts +++ b/packages/core/src/sandbox/windows/WindowsSandboxManager.ts @@ -16,7 +16,6 @@ import { findSecretFiles, type GlobalSandboxOptions, sanitizePaths, - tryRealpath, type SandboxPermissions, type ParsedSandboxDenial, resolveSandboxPaths, @@ -36,23 +35,28 @@ import { } from './commandSafety.js'; import { verifySandboxOverrides } from '../utils/commandUtils.js'; import { parseWindowsSandboxDenials } from './windowsSandboxDenialUtils.js'; +import { isSubpath, resolveToRealPath } from '../../utils/paths.js'; const __filename = fileURLToPath(import.meta.url); const __dirname = path.dirname(__filename); +// S-1-16-4096 is the SID for "Low Mandatory Level" (Low Integrity) +const LOW_INTEGRITY_SID = '*S-1-16-4096'; + /** * A SandboxManager implementation for Windows that uses Restricted Tokens, * Job Objects, and Low Integrity levels for process isolation. * Uses a native C# helper to bypass PowerShell restrictions. */ export class WindowsSandboxManager implements SandboxManager { + static readonly HELPER_EXE = 'GeminiSandbox.exe'; private readonly helperPath: string; private initialized = false; private readonly allowedCache = new Set(); private readonly deniedCache = new Set(); constructor(private readonly options: GlobalSandboxOptions) { - this.helperPath = path.resolve(__dirname, 'GeminiSandbox.exe'); + this.helperPath = path.resolve(__dirname, WindowsSandboxManager.HELPER_EXE); } isKnownSafeCommand(args: string[]): boolean { @@ -76,6 +80,10 @@ export class WindowsSandboxManager implements SandboxManager { return this.options.workspace; } + getOptions(): GlobalSandboxOptions { + return this.options; + } + /** * Ensures a file or directory exists. */ @@ -259,9 +267,14 @@ export class WindowsSandboxManager implements SandboxManager { this.options.modeConfig?.network ?? req.policy?.networkAccess ?? false; const networkAccess = defaultNetwork || mergedAdditional.network; - // 1. Handle filesystem permissions for Low Integrity - // Grant "Low Mandatory Level" write access to the workspace. - // If not in readonly mode OR it's a strictly approved pipeline, allow workspace writes + const { allowed: allowedPaths, forbidden: forbiddenPaths } = + await resolveSandboxPaths(this.options, req); + + // Track all roots where Low Integrity write access has been granted. + // New files created within these roots will inherit the Low label. + const writableRoots: string[] = []; + + // 1. Workspace access const isApproved = allowOverrides ? await isStrictlyApproved( command, @@ -272,20 +285,19 @@ export class WindowsSandboxManager implements SandboxManager { if (!isReadonlyMode || isApproved) { await this.grantLowIntegrityAccess(this.options.workspace); + writableRoots.push(this.options.workspace); } - const { allowed: allowedPaths, forbidden: forbiddenPaths } = - await resolveSandboxPaths(this.options, req); - - // Grant "Low Mandatory Level" access to includeDirectories. + // 2. Globally included directories const includeDirs = sanitizePaths(this.options.includeDirectories); for (const includeDir of includeDirs) { await this.grantLowIntegrityAccess(includeDir); + writableRoots.push(includeDir); } - // Grant "Low Mandatory Level" read/write access to allowedPaths. + // 3. Explicitly allowed paths from the request policy for (const allowedPath of allowedPaths) { - const resolved = await tryRealpath(allowedPath); + const resolved = resolveToRealPath(allowedPath); try { await fs.promises.access(resolved, fs.constants.F_OK); } catch { @@ -295,23 +307,32 @@ export class WindowsSandboxManager implements SandboxManager { ); } await this.grantLowIntegrityAccess(resolved); + writableRoots.push(resolved); } - // Grant "Low Mandatory Level" write access to additional permissions write paths. + // 4. Additional write paths (e.g. from internal __write command) const additionalWritePaths = sanitizePaths( mergedAdditional.fileSystem?.write, ); for (const writePath of additionalWritePaths) { - const resolved = await tryRealpath(writePath); + const resolved = resolveToRealPath(writePath); try { await fs.promises.access(resolved, fs.constants.F_OK); + await this.grantLowIntegrityAccess(resolved); + continue; } catch { - throw new Error( - `Sandbox request rejected: Additional write path does not exist: ${resolved}. ` + - 'On Windows, granular sandbox access can only be granted to existing paths to avoid broad parent directory permissions.', + // If the file doesn't exist, it's only allowed if it resides within a granted root. + const isInherited = writableRoots.some((root) => + isSubpath(root, resolved), ); + + if (!isInherited) { + throw new Error( + `Sandbox request rejected: Additional write path does not exist and its parent directory is not allowed: ${resolved}. ` + + 'On Windows, granular sandbox access can only be granted to existing paths to avoid broad parent directory permissions.', + ); + } } - await this.grantLowIntegrityAccess(resolved); } // 2. Collect secret files and apply protective ACLs @@ -382,15 +403,6 @@ export class WindowsSandboxManager implements SandboxManager { const manifestPath = path.join(tempDir, 'manifest.txt'); fs.writeFileSync(manifestPath, allForbidden.join('\n')); - // Cleanup on exit - process.on('exit', () => { - try { - fs.rmSync(tempDir, { recursive: true, force: true }); - } catch { - // Ignore errors - } - }); - // 5. Construct the helper command // GeminiSandbox.exe --forbidden-manifest [args...] const program = this.helperPath; @@ -411,6 +423,13 @@ export class WindowsSandboxManager implements SandboxManager { args: finalArgs, env: finalEnv, cwd: req.cwd, + cleanup: () => { + try { + fs.rmSync(tempDir, { recursive: true, force: true }); + } catch { + // Ignore errors + } + }, }; } @@ -422,7 +441,7 @@ export class WindowsSandboxManager implements SandboxManager { return; } - const resolvedPath = await tryRealpath(targetPath); + const resolvedPath = resolveToRealPath(targetPath); if (this.allowedCache.has(resolvedPath)) { return; } @@ -446,8 +465,12 @@ export class WindowsSandboxManager implements SandboxManager { } try { + // 1. Grant explicit Modify access to the Low Integrity SID + // 2. Set the Mandatory Label to Low to allow "Write Up" from Low processes await spawnAsync('icacls', [ resolvedPath, + '/grant', + `${LOW_INTEGRITY_SID}:(OI)(CI)(M)`, '/setintegritylevel', '(OI)(CI)Low', ]); @@ -469,7 +492,7 @@ export class WindowsSandboxManager implements SandboxManager { return; } - const resolvedPath = await tryRealpath(targetPath); + const resolvedPath = resolveToRealPath(targetPath); if (this.deniedCache.has(resolvedPath)) { return; } @@ -479,9 +502,6 @@ export class WindowsSandboxManager implements SandboxManager { return; } - // S-1-16-4096 is the SID for "Low Mandatory Level" (Low Integrity) - const LOW_INTEGRITY_SID = '*S-1-16-4096'; - // icacls flags: (OI) Object Inherit, (CI) Container Inherit, (F) Full Access Deny. // Omit /T (recursive) for performance; (OI)(CI) ensures inheritance for new items. // Windows dynamically evaluates existing items, though deep explicit Allow ACEs diff --git a/packages/core/src/services/sandboxManager.integration.test.ts b/packages/core/src/services/sandboxManager.integration.test.ts index 524726cdd4..4923de97bf 100644 --- a/packages/core/src/services/sandboxManager.integration.test.ts +++ b/packages/core/src/services/sandboxManager.integration.test.ts @@ -28,7 +28,14 @@ const Platform = { /** Returns a command to create an empty file. */ touch(filePath: string) { return this.isWindows - ? { command: 'cmd.exe', args: ['/c', `type nul > "${filePath}"`] } + ? { + command: 'powershell.exe', + args: [ + '-NoProfile', + '-Command', + `New-Item -Path "${filePath}" -ItemType File -Force`, + ], + } : { command: 'touch', args: [filePath] }; }, @@ -48,18 +55,13 @@ const Platform = { /** Returns a command to perform a network request. */ curl(url: string) { - return this.isWindows - ? { - command: 'powershell.exe', - args: ['-Command', `Invoke-WebRequest -Uri ${url} -TimeoutSec 1`], - } - : { command: 'curl', args: ['-s', '--connect-timeout', '1', url] }; + return { command: 'curl', args: ['-s', '--connect-timeout', '1', url] }; }, /** Returns a command that checks if the current terminal is interactive. */ isPty() { return this.isWindows - ? 'cmd.exe /c echo True' + ? 'powershell.exe -NoProfile -Command "echo True"' : 'bash -c "if [ -t 1 ]; then echo True; else echo False; fi"'; }, @@ -103,7 +105,7 @@ function ensureSandboxAvailable(): boolean { if (platform === 'win32') { // Windows sandboxing relies on icacls, which is a core system utility and // always available. - // TODO: reenable once test is fixed + // TODO: reenable once flakiness is addressed return false; } @@ -167,23 +169,28 @@ describe('SandboxManager Integration', () => { expect(result.stdout.trim()).toBe('sandbox test'); }); - it('supports interactive pseudo-terminals (node-pty)', async () => { - const handle = await ShellExecutionService.execute( - Platform.isPty(), - workspace, - () => {}, - new AbortController().signal, - true, - { - sanitizationConfig: getSecureSanitizationConfig(), - sandboxManager: manager, - }, - ); + // The Windows sandbox wrapper (GeminiSandbox.exe) uses standard pipes + // for I/O interception, which breaks ConPTY pseudo-terminal inheritance. + it.skipIf(Platform.isWindows)( + 'supports interactive pseudo-terminals (node-pty)', + async () => { + const handle = await ShellExecutionService.execute( + Platform.isPty(), + workspace, + () => {}, + new AbortController().signal, + true, + { + sanitizationConfig: getSecureSanitizationConfig(), + sandboxManager: manager, + }, + ); - const result = await handle.result; - expect(result.exitCode).toBe(0); - expect(result.output).toContain('True'); - }); + const result = await handle.result; + expect(result.exitCode).toBe(0); + expect(result.output).toContain('True'); + }, + ); }); describe('File System Access', () => { @@ -511,18 +518,23 @@ describe('SandboxManager Integration', () => { if (server) await new Promise((res) => server.close(() => res())); }); - it('blocks network access by default', async () => { - const { command, args } = Platform.curl(url); - const sandboxed = await manager.prepareCommand({ - command, - args, - cwd: workspace, - env: process.env, - }); + // Windows Job Object rate limits exempt loopback (127.0.0.1) traffic, + // so this test cannot verify loopback blocking on Windows. + it.skipIf(Platform.isWindows)( + 'blocks network access by default', + async () => { + const { command, args } = Platform.curl(url); + const sandboxed = await manager.prepareCommand({ + command, + args, + cwd: workspace, + env: process.env, + }); - const result = await runCommand(sandboxed); - expect(result.status).not.toBe(0); - }); + const result = await runCommand(sandboxed); + expect(result.status).not.toBe(0); + }, + ); it('grants network access when explicitly allowed', async () => { const { command, args } = Platform.curl(url); diff --git a/packages/core/src/services/sandboxManager.ts b/packages/core/src/services/sandboxManager.ts index 7260551d35..673c13b9af 100644 --- a/packages/core/src/services/sandboxManager.ts +++ b/packages/core/src/services/sandboxManager.ts @@ -146,6 +146,11 @@ export interface SandboxManager { * Returns the primary workspace directory for this sandbox. */ getWorkspace(): string; + + /** + * Returns the global sandbox options for this sandbox. + */ + getOptions(): GlobalSandboxOptions | undefined; } /** @@ -283,6 +288,10 @@ export class NoopSandboxManager implements SandboxManager { getWorkspace(): string { return this.options?.workspace ?? process.cwd(); } + + getOptions(): GlobalSandboxOptions | undefined { + return this.options; + } } /** @@ -310,6 +319,10 @@ export class LocalSandboxManager implements SandboxManager { getWorkspace(): string { return this.options?.workspace ?? process.cwd(); } + + getOptions(): GlobalSandboxOptions | undefined { + return this.options; + } } /** diff --git a/packages/core/src/services/sandboxedFileSystemService.test.ts b/packages/core/src/services/sandboxedFileSystemService.test.ts index 83b7247d70..83d5e9896a 100644 --- a/packages/core/src/services/sandboxedFileSystemService.test.ts +++ b/packages/core/src/services/sandboxedFileSystemService.test.ts @@ -18,6 +18,7 @@ import type { SandboxManager, SandboxRequest, SandboxedCommand, + GlobalSandboxOptions, } from './sandboxManager.js'; import { spawn, type ChildProcess } from 'node:child_process'; import { EventEmitter } from 'node:events'; @@ -52,6 +53,13 @@ class MockSandboxManager implements SandboxManager { getWorkspace(): string { return path.resolve('/workspace'); } + + getOptions(): GlobalSandboxOptions | undefined { + return { + workspace: path.resolve('/workspace'), + includeDirectories: [path.resolve('/test/cwd')], + }; + } } describe('SandboxedFileSystemService', () => { diff --git a/packages/core/src/services/sandboxedFileSystemService.ts b/packages/core/src/services/sandboxedFileSystemService.ts index 2a5d3d08ac..03907657f3 100644 --- a/packages/core/src/services/sandboxedFileSystemService.ts +++ b/packages/core/src/services/sandboxedFileSystemService.ts @@ -22,12 +22,29 @@ export class SandboxedFileSystemService implements FileSystemService { private sanitizeAndValidatePath(filePath: string): string { const resolvedPath = resolveToRealPath(filePath); - if (!isSubpath(this.cwd, resolvedPath) && this.cwd !== resolvedPath) { - throw new Error( - `Access denied: Path '${filePath}' is outside the workspace.`, - ); + const workspace = resolveToRealPath(this.sandboxManager.getWorkspace()); + + if (isSubpath(workspace, resolvedPath) || workspace === resolvedPath) { + return resolvedPath; } - return resolvedPath; + + // Check if the path is explicitly allowed by the sandbox manager + const options = this.sandboxManager.getOptions(); + const allowedPaths = options?.includeDirectories ?? []; + + for (const allowed of allowedPaths) { + const resolvedAllowed = resolveToRealPath(allowed); + if ( + isSubpath(resolvedAllowed, resolvedPath) || + resolvedAllowed === resolvedPath + ) { + return resolvedPath; + } + } + + throw new Error( + `Access denied: Path '${filePath}' is outside the workspace and not in allowed paths.`, + ); } async readTextFile(filePath: string): Promise { diff --git a/packages/core/src/services/shellExecutionService.test.ts b/packages/core/src/services/shellExecutionService.test.ts index 0fc20225ac..a7b21ebefc 100644 --- a/packages/core/src/services/shellExecutionService.test.ts +++ b/packages/core/src/services/shellExecutionService.test.ts @@ -155,6 +155,7 @@ const createMockSerializeTerminalToObjectReturnValue = ( underline: false, dim: false, inverse: false, + isUninitialized: false, fg: '#ffffff', bg: '#000000', }, @@ -173,6 +174,7 @@ const createExpectedAnsiOutput = (text: string | string[]): AnsiOutput => { underline: false, dim: false, inverse: false, + isUninitialized: false, fg: '', bg: '', } as AnsiToken, @@ -2015,6 +2017,7 @@ describe('ShellExecutionService environment variables', () => { isDangerousCommand: vi.fn().mockReturnValue(false), parseDenials: vi.fn().mockReturnValue(undefined), getWorkspace: vi.fn().mockReturnValue('/workspace'), + getOptions: vi.fn().mockReturnValue(undefined), }; const configWithSandbox: ShellExecutionConfig = { diff --git a/packages/core/src/telemetry/clearcut-logger/clearcut-logger.test.ts b/packages/core/src/telemetry/clearcut-logger/clearcut-logger.test.ts index de1aaeb32f..292588c7a1 100644 --- a/packages/core/src/telemetry/clearcut-logger/clearcut-logger.test.ts +++ b/packages/core/src/telemetry/clearcut-logger/clearcut-logger.test.ts @@ -1692,4 +1692,187 @@ describe('ClearcutLogger', () => { ]); }); }); + + describe('logBrowserAgentConnectionEvent', () => { + it('logs a successful connection event', () => { + const { logger } = setup(); + logger?.logBrowserAgentConnectionEvent({ + session_mode: 'isolated', + headless: true, + success: true, + duration_ms: 1500, + }); + + const events = getEvents(logger!); + expect(events.length).toBe(1); + expect(events[0]).toHaveEventName(EventNames.BROWSER_AGENT_CONNECTION); + expect(events[0]).toHaveMetadataValue([ + EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_SESSION_MODE, + 'isolated', + ]); + expect(events[0]).toHaveMetadataValue([ + EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_HEADLESS, + 'true', + ]); + expect(events[0]).toHaveMetadataValue([ + EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_SUCCESS, + 'true', + ]); + expect(events[0]).toHaveMetadataValue([ + EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_DURATION_MS, + '1500', + ]); + }); + + it('logs a failed connection event with error_type', () => { + const { logger } = setup(); + logger?.logBrowserAgentConnectionEvent({ + session_mode: 'persistent', + headless: false, + success: false, + duration_ms: 30000, + error_type: 'timeout', + }); + + const events = getEvents(logger!); + expect(events.length).toBe(1); + expect(events[0]).toHaveMetadataValue([ + EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_SUCCESS, + 'false', + ]); + expect(events[0]).toHaveMetadataValue([ + EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_ERROR_TYPE, + 'timeout', + ]); + }); + + it('logs tool_count when provided', () => { + const { logger } = setup(); + logger?.logBrowserAgentConnectionEvent({ + session_mode: 'existing', + headless: true, + success: true, + duration_ms: 800, + tool_count: 12, + }); + + const events = getEvents(logger!); + expect(events[0]).toHaveMetadataValue([ + EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_TOOL_COUNT, + '12', + ]); + }); + }); + + describe('logBrowserAgentVisionStatusEvent', () => { + it('logs vision enabled', () => { + const { logger } = setup(); + logger?.logBrowserAgentVisionStatusEvent({ enabled: true }); + + const events = getEvents(logger!); + expect(events.length).toBe(1); + expect(events[0]).toHaveEventName(EventNames.BROWSER_AGENT_VISION_STATUS); + expect(events[0]).toHaveMetadataValue([ + EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_VISION_ENABLED, + 'true', + ]); + }); + + it('logs vision disabled with reason', () => { + const { logger } = setup(); + logger?.logBrowserAgentVisionStatusEvent({ + enabled: false, + disabled_reason: 'no_visual_model', + }); + + const events = getEvents(logger!); + expect(events[0]).toHaveMetadataValue([ + EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_VISION_ENABLED, + 'false', + ]); + expect(events[0]).toHaveMetadataValue([ + EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_VISION_DISABLED_REASON, + 'no_visual_model', + ]); + }); + }); + + describe('logBrowserAgentTaskOutcomeEvent', () => { + it('logs a task outcome event with all attributes', () => { + const { logger } = setup(); + logger?.logBrowserAgentTaskOutcomeEvent({ + success: true, + session_mode: 'isolated', + vision_enabled: true, + headless: true, + duration_ms: 5000, + }); + + const events = getEvents(logger!); + expect(events.length).toBe(1); + expect(events[0]).toHaveEventName(EventNames.BROWSER_AGENT_TASK_OUTCOME); + expect(events[0]).toHaveMetadataValue([ + EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_SUCCESS, + 'true', + ]); + expect(events[0]).toHaveMetadataValue([ + EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_SESSION_MODE, + 'isolated', + ]); + expect(events[0]).toHaveMetadataValue([ + EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_VISION_ENABLED, + 'true', + ]); + expect(events[0]).toHaveMetadataValue([ + EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_HEADLESS, + 'true', + ]); + expect(events[0]).toHaveMetadataValue([ + EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_DURATION_MS, + '5000', + ]); + }); + }); + + describe('logBrowserAgentCleanupEvent', () => { + it('logs a cleanup event with all attributes', () => { + const { logger } = setup(); + logger?.logBrowserAgentCleanupEvent({ + session_mode: 'isolated', + success: true, + duration_ms: 200, + }); + + const events = getEvents(logger!); + expect(events.length).toBe(1); + expect(events[0]).toHaveEventName(EventNames.BROWSER_AGENT_CLEANUP); + expect(events[0]).toHaveMetadataValue([ + EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_SESSION_MODE, + 'isolated', + ]); + expect(events[0]).toHaveMetadataValue([ + EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_SUCCESS, + 'true', + ]); + expect(events[0]).toHaveMetadataValue([ + EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_DURATION_MS, + '200', + ]); + }); + + it('logs a failed cleanup event', () => { + const { logger } = setup(); + logger?.logBrowserAgentCleanupEvent({ + session_mode: 'persistent', + success: false, + duration_ms: 5000, + }); + + const events = getEvents(logger!); + expect(events[0]).toHaveMetadataValue([ + EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_SUCCESS, + 'false', + ]); + }); + }); }); diff --git a/packages/core/src/telemetry/clearcut-logger/clearcut-logger.ts b/packages/core/src/telemetry/clearcut-logger/clearcut-logger.ts index 2915edf712..a5896d57f3 100644 --- a/packages/core/src/telemetry/clearcut-logger/clearcut-logger.ts +++ b/packages/core/src/telemetry/clearcut-logger/clearcut-logger.ts @@ -135,6 +135,10 @@ export enum EventNames { OVERAGE_OPTION_SELECTED = 'overage_option_selected', EMPTY_WALLET_MENU_SHOWN = 'empty_wallet_menu_shown', CREDIT_PURCHASE_CLICK = 'credit_purchase_click', + BROWSER_AGENT_CONNECTION = 'browser_agent_connection', + BROWSER_AGENT_VISION_STATUS = 'browser_agent_vision_status', + BROWSER_AGENT_TASK_OUTCOME = 'browser_agent_task_outcome', + BROWSER_AGENT_CLEANUP = 'browser_agent_cleanup', } export interface LogResponse { @@ -1935,6 +1939,146 @@ export class ClearcutLogger { this.flushIfNeeded(); } + // ========================================================================== + // Browser Agent Events + // ========================================================================== + + logBrowserAgentConnectionEvent(attrs: { + session_mode: string; + headless: boolean; + success: boolean; + duration_ms: number; + error_type?: string; + tool_count?: number; + }): void { + const data: EventValue[] = [ + { + gemini_cli_key: EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_SESSION_MODE, + value: attrs.session_mode, + }, + { + gemini_cli_key: EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_HEADLESS, + value: attrs.headless.toString(), + }, + { + gemini_cli_key: EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_SUCCESS, + value: attrs.success.toString(), + }, + { + gemini_cli_key: EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_DURATION_MS, + value: attrs.duration_ms.toString(), + }, + ]; + + if (attrs.error_type) { + data.push({ + gemini_cli_key: EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_ERROR_TYPE, + value: attrs.error_type, + }); + } + + if (attrs.tool_count !== undefined) { + data.push({ + gemini_cli_key: EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_TOOL_COUNT, + value: attrs.tool_count.toString(), + }); + } + + this.enqueueLogEvent( + this.createLogEvent(EventNames.BROWSER_AGENT_CONNECTION, data), + ); + this.flushIfNeeded(); + } + + logBrowserAgentVisionStatusEvent(attrs: { + enabled: boolean; + disabled_reason?: string; + }): void { + const data: EventValue[] = [ + { + gemini_cli_key: + EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_VISION_ENABLED, + value: attrs.enabled.toString(), + }, + ]; + + if (attrs.disabled_reason) { + data.push({ + gemini_cli_key: + EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_VISION_DISABLED_REASON, + value: attrs.disabled_reason, + }); + } + + this.enqueueLogEvent( + this.createLogEvent(EventNames.BROWSER_AGENT_VISION_STATUS, data), + ); + this.flushIfNeeded(); + } + + logBrowserAgentTaskOutcomeEvent(attrs: { + success: boolean; + session_mode: string; + vision_enabled: boolean; + headless: boolean; + duration_ms: number; + }): void { + const data: EventValue[] = [ + { + gemini_cli_key: EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_SUCCESS, + value: attrs.success.toString(), + }, + { + gemini_cli_key: EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_SESSION_MODE, + value: attrs.session_mode, + }, + { + gemini_cli_key: + EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_VISION_ENABLED, + value: attrs.vision_enabled.toString(), + }, + { + gemini_cli_key: EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_HEADLESS, + value: attrs.headless.toString(), + }, + { + gemini_cli_key: EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_DURATION_MS, + value: attrs.duration_ms.toString(), + }, + ]; + + this.enqueueLogEvent( + this.createLogEvent(EventNames.BROWSER_AGENT_TASK_OUTCOME, data), + ); + this.flushIfNeeded(); + } + + logBrowserAgentCleanupEvent(attrs: { + session_mode: string; + success: boolean; + duration_ms: number; + }): void { + const data: EventValue[] = [ + { + gemini_cli_key: EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_SESSION_MODE, + value: attrs.session_mode, + }, + { + gemini_cli_key: EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_SUCCESS, + value: attrs.success.toString(), + }, + { + gemini_cli_key: EventMetadataKey.GEMINI_CLI_BROWSER_AGENT_DURATION_MS, + value: attrs.duration_ms.toString(), + }, + ]; + + this.enqueueLogEvent( + this.createLogEvent(EventNames.BROWSER_AGENT_CLEANUP, data), + ); + this.flushIfNeeded(); + } + /** * Adds default fields to data, and returns a new data array. This fields * should exist on all log events. diff --git a/packages/core/src/telemetry/clearcut-logger/event-metadata-key.ts b/packages/core/src/telemetry/clearcut-logger/event-metadata-key.ts index b5688a3e65..b9e7b2b75c 100644 --- a/packages/core/src/telemetry/clearcut-logger/event-metadata-key.ts +++ b/packages/core/src/telemetry/clearcut-logger/event-metadata-key.ts @@ -7,7 +7,7 @@ // Defines valid event metadata keys for Clearcut logging. export enum EventMetadataKey { // Deleted enums: 24 - // Next ID: 195 + // Next ID: 203 GEMINI_CLI_KEY_UNKNOWN = 0, @@ -725,4 +725,32 @@ export enum EventMetadataKey { // Logs the duration of the onboarding process in milliseconds. GEMINI_CLI_ONBOARDING_DURATION_MS = 194, + + // ========================================================================== + // Browser Agent Event Keys + // ========================================================================== + + // Logs the browser agent session mode (persistent, isolated, existing). + GEMINI_CLI_BROWSER_AGENT_SESSION_MODE = 195, + + // Logs whether the browser agent ran in headless mode. + GEMINI_CLI_BROWSER_AGENT_HEADLESS = 196, + + // Logs whether the browser agent operation was successful. + GEMINI_CLI_BROWSER_AGENT_SUCCESS = 197, + + // Logs the error type for a browser agent connection failure. + GEMINI_CLI_BROWSER_AGENT_ERROR_TYPE = 198, + + // Logs the duration in milliseconds for a browser agent operation. + GEMINI_CLI_BROWSER_AGENT_DURATION_MS = 199, + + // Logs whether vision mode was enabled for the browser agent. + GEMINI_CLI_BROWSER_AGENT_VISION_ENABLED = 200, + + // Logs the reason vision mode was disabled for the browser agent. + GEMINI_CLI_BROWSER_AGENT_VISION_DISABLED_REASON = 201, + + // Logs the number of tools discovered from the MCP server. + GEMINI_CLI_BROWSER_AGENT_TOOL_COUNT = 202, } diff --git a/packages/core/src/telemetry/loggers.ts b/packages/core/src/telemetry/loggers.ts index a33c8ca200..a3c3cb48ee 100644 --- a/packages/core/src/telemetry/loggers.ts +++ b/packages/core/src/telemetry/loggers.ts @@ -83,6 +83,10 @@ import { recordInvalidChunk, recordOnboardingStart, recordOnboardingSuccess, + recordBrowserAgentConnection, + recordBrowserAgentVisionStatus, + recordBrowserAgentTaskOutcome, + recordBrowserAgentCleanup, } from './metrics.js'; import { bufferTelemetryEvent } from './sdk.js'; import { uiTelemetryService, type UiEvent } from './uiTelemetry.js'; @@ -939,3 +943,90 @@ export function logBillingEvent( } } } + +// ========================================================================== +// Browser Agent Events +// ========================================================================== + +export function logBrowserAgentConnection( + config: Config, + durationMs: number, + attributes: { + session_mode: 'persistent' | 'isolated' | 'existing'; + headless: boolean; + success: boolean; + error_type?: + | 'profile_locked' + | 'timeout' + | 'connection_refused' + | 'unknown'; + tool_count?: number; + }, +): void { + ClearcutLogger.getInstance(config)?.logBrowserAgentConnectionEvent({ + session_mode: attributes.session_mode, + headless: attributes.headless, + success: attributes.success, + duration_ms: durationMs, + error_type: attributes.error_type, + tool_count: attributes.tool_count, + }); + + recordBrowserAgentConnection(config, durationMs, attributes); +} + +export function logBrowserAgentVisionStatus( + config: Config, + attributes: { + enabled: boolean; + disabled_reason?: + | 'no_visual_model' + | 'missing_visual_tools' + | 'blocked_auth_type'; + }, +): void { + ClearcutLogger.getInstance(config)?.logBrowserAgentVisionStatusEvent({ + enabled: attributes.enabled, + disabled_reason: attributes.disabled_reason, + }); + + recordBrowserAgentVisionStatus(config, attributes); +} + +export function logBrowserAgentTaskOutcome( + config: Config, + attributes: { + success: boolean; + session_mode: 'persistent' | 'isolated' | 'existing'; + vision_enabled: boolean; + headless: boolean; + duration_ms: number; + }, +): void { + ClearcutLogger.getInstance(config)?.logBrowserAgentTaskOutcomeEvent({ + success: attributes.success, + session_mode: attributes.session_mode, + vision_enabled: attributes.vision_enabled, + headless: attributes.headless, + duration_ms: attributes.duration_ms, + }); + + recordBrowserAgentTaskOutcome(config, attributes); +} + +export function logBrowserAgentCleanup( + config: Config, + durationMs: number, + attributes: { + session_mode: 'persistent' | 'isolated' | 'existing'; + success: boolean; + }, +): void { + ClearcutLogger.getInstance(config)?.logBrowserAgentCleanupEvent({ + session_mode: attributes.session_mode, + success: attributes.success, + duration_ms: durationMs, + }); + + recordBrowserAgentCleanup(config, durationMs, attributes); +} diff --git a/packages/core/src/telemetry/metrics.test.ts b/packages/core/src/telemetry/metrics.test.ts index c3d16f977e..0bca699b16 100644 --- a/packages/core/src/telemetry/metrics.test.ts +++ b/packages/core/src/telemetry/metrics.test.ts @@ -1687,6 +1687,29 @@ describe('Telemetry Metrics', () => { expect(mockCounterAddFn).not.toHaveBeenCalled(); }); + it('records tool_count on success when provided', () => { + initializeMetricsModule(mockConfig); + mockCounterAddFn.mockClear(); + mockHistogramRecordFn.mockClear(); + + recordBrowserAgentConnectionModule(mockConfig, 1200, { + session_mode: 'isolated', + headless: false, + success: true, + tool_count: 5, + }); + + expect(mockHistogramRecordFn).toHaveBeenCalledWith(1200, { + 'session.id': 'test-session-id', + 'installation.id': 'test-installation-id', + 'user.email': 'test@example.com', + session_mode: 'isolated', + headless: false, + success: true, + tool_count: 5, + }); + }); + it('records connection duration and failure counter on error', () => { initializeMetricsModule(mockConfig); mockCounterAddFn.mockClear(); diff --git a/packages/core/src/telemetry/metrics.ts b/packages/core/src/telemetry/metrics.ts index 5c2fedfbed..422f0222a5 100644 --- a/packages/core/src/telemetry/metrics.ts +++ b/packages/core/src/telemetry/metrics.ts @@ -1624,6 +1624,7 @@ export function recordBrowserAgentConnection( | 'timeout' | 'connection_refused' | 'unknown'; + tool_count?: number; }, ): void { if (!isMetricsInitialized) return; @@ -1635,6 +1636,7 @@ export function recordBrowserAgentConnection( session_mode: attributes.session_mode, headless: attributes.headless, success: attributes.success, + tool_count: attributes.tool_count, }); if (!attributes.success && browserAgentConnectionFailureCounter) { diff --git a/packages/core/src/tools/shell.test.ts b/packages/core/src/tools/shell.test.ts index 4a3ac48f00..245b7f0eee 100644 --- a/packages/core/src/tools/shell.test.ts +++ b/packages/core/src/tools/shell.test.ts @@ -154,7 +154,11 @@ describe('ShellTool', () => { return mockSandboxManager; }, sandboxPolicyManager: { - getCommandPermissions: vi.fn().mockReturnValue(undefined), + getCommandPermissions: vi.fn().mockReturnValue({ + fileSystem: { read: [], write: [] }, + network: false, + }), + getModeConfig: vi.fn().mockReturnValue({ readonly: false }), addPersistentApproval: vi.fn(), addSessionApproval: vi.fn(), @@ -708,6 +712,39 @@ describe('ShellTool', () => { it('should throw an error if validation fails', () => { expect(() => shellTool.build({ command: '' })).toThrow(); }); + + it('should NOT return a sandbox expansion prompt for npm install when sandboxing is disabled', async () => { + const bus = (shellTool as unknown as { messageBus: MessageBus }) + .messageBus; + const mockBus = getMockMessageBusInstance( + bus, + ) as unknown as TestableMockMessageBus; + mockBus.defaultToolDecision = 'allow'; + + vi.mocked(mockConfig.getSandboxEnabled).mockReturnValue(false); + const params = { command: 'npm install' }; + const invocation = shellTool.build(params); + + const confirmation = await invocation.shouldConfirmExecute( + new AbortController().signal, + ); + + // Should be false because standard confirm mode is 'allow' + expect(confirmation).toBe(false); + }); + + it('should return a sandbox expansion prompt for npm install when sandboxing is enabled', async () => { + vi.mocked(mockConfig.getSandboxEnabled).mockReturnValue(true); + const params = { command: 'npm install' }; + const invocation = shellTool.build(params); + + const confirmation = await invocation.shouldConfirmExecute( + new AbortController().signal, + ); + + expect(confirmation).not.toBe(false); + expect(confirmation && confirmation.type).toBe('sandbox_expansion'); + }); }); describe('getDescription', () => { @@ -950,6 +987,10 @@ describe('ShellTool', () => { describe('sandbox heuristics', () => { const mockAbortSignal = new AbortController().signal; + beforeEach(() => { + vi.mocked(mockConfig.getSandboxEnabled).mockReturnValue(true); + }); + it('should suggest proactive permissions for npm commands', async () => { const homeDir = path.join(tempRootDir, 'home'); fs.mkdirSync(homeDir); diff --git a/packages/core/src/tools/shell.ts b/packages/core/src/tools/shell.ts index a467ef4c63..7ca475808a 100644 --- a/packages/core/src/tools/shell.ts +++ b/packages/core/src/tools/shell.ts @@ -10,7 +10,10 @@ import path from 'node:path'; import os from 'node:os'; import crypto from 'node:crypto'; import { debugLogger } from '../index.js'; -import type { SandboxPermissions } from '../services/sandboxManager.js'; +import { + type SandboxPermissions, + getPathIdentity, +} from '../services/sandboxManager.js'; import { ToolErrorType } from './tool-error.js'; import { BaseDeclarativeTool, @@ -42,6 +45,7 @@ import { stripShellWrapper, parseCommandDetails, hasRedirection, + normalizeCommand, } from '../utils/shell-utils.js'; import { SHELL_TOOL_NAME } from './tool-names.js'; import { PARAM_ADDITIONAL_PERMISSIONS } from './definitions/base-declarations.js'; @@ -49,7 +53,7 @@ import type { MessageBus } from '../confirmation-bus/message-bus.js'; import { getShellDefinition } from './definitions/coreTools.js'; import { resolveToolDeclaration } from './definitions/resolver.js'; import type { AgentLoopContext } from '../config/agent-loop-context.js'; -import { isSubpath } from '../utils/paths.js'; +import { isSubpath, resolveToRealPath } from '../utils/paths.js'; import { getProactiveToolSuggestions, isNetworkReliantCommand, @@ -132,7 +136,7 @@ export class ShellToolInvocation extends BaseToolInvocation< } getDescription(): string { - return `${this.params.command} ${this.getContextualDetails()}`; + return this.params.description || ''; } private simplifyPaths(paths: Set): string[] { @@ -247,77 +251,103 @@ export class ShellToolInvocation extends BaseToolInvocation< return this.getConfirmationDetails(abortSignal); } - // Proactively suggest expansion for known network-heavy Node.js ecosystem tools - // (npm install, etc.) to avoid hangs when network is restricted by default. - // We do this even if the command is "allowed" by policy because the DEFAULT - // permissions are usually insufficient for these commands. - const command = stripShellWrapper(this.params.command); - const rootCommands = getCommandRoots(command); - const rootCommand = rootCommands[0]; + if (this.context.config.getSandboxEnabled()) { + const command = stripShellWrapper(this.params.command); + const rootCommands = getCommandRoots(command); + const rawRootCommand = rootCommands[0]; - if (rootCommand) { - const proactive = await getProactiveToolSuggestions(rootCommand); - if (proactive) { - const approved = - this.context.config.sandboxPolicyManager.getCommandPermissions( - rootCommand, - ); - const missingNetwork = !!proactive.network && !approved?.network; - - // Detect commands or sub-commands that definitely need network - const parsed = parseCommandDetails(command); - const subCommand = parsed?.details[0]?.args?.[0]; - const needsNetwork = isNetworkReliantCommand(rootCommand, subCommand); - - if (needsNetwork) { - // Add write permission to the current directory if we are in readonly mode + if (rawRootCommand) { + const rootCommand = normalizeCommand(rawRootCommand); + const proactive = await getProactiveToolSuggestions(rootCommand); + if (proactive) { const mode = this.context.config.getApprovalMode(); - const isReadonlyMode = - this.context.config.sandboxPolicyManager.getModeConfig(mode) - ?.readonly ?? false; + const modeConfig = + this.context.config.sandboxPolicyManager.getModeConfig(mode); + const approved = + this.context.config.sandboxPolicyManager.getCommandPermissions( + rootCommand, + ); - if (isReadonlyMode) { - const cwd = - this.params.dir_path || this.context.config.getTargetDir(); - proactive.fileSystem = proactive.fileSystem || { - read: [], - write: [], - }; - proactive.fileSystem.write = proactive.fileSystem.write || []; - if (!proactive.fileSystem.write.includes(cwd)) { - proactive.fileSystem.write.push(cwd); - proactive.fileSystem.read = proactive.fileSystem.read || []; - if (!proactive.fileSystem.read.includes(cwd)) { - proactive.fileSystem.read.push(cwd); + const hasNetwork = modeConfig.network || approved.network; + const missingNetwork = !!proactive.network && !hasNetwork; + + // Detect commands or sub-commands that definitely need network + const parsed = parseCommandDetails(command); + const subCommand = parsed?.details[0]?.args?.[0]; + const needsNetwork = isNetworkReliantCommand(rootCommand, subCommand); + + if (needsNetwork) { + // Add write permission to the current directory if we are in readonly mode + const isReadonlyMode = modeConfig.readonly ?? false; + + if (isReadonlyMode) { + const cwd = + this.params.dir_path || this.context.config.getTargetDir(); + proactive.fileSystem = proactive.fileSystem || { + read: [], + write: [], + }; + proactive.fileSystem.write = proactive.fileSystem.write || []; + if (!proactive.fileSystem.write.includes(cwd)) { + proactive.fileSystem.write.push(cwd); + proactive.fileSystem.read = proactive.fileSystem.read || []; + if (!proactive.fileSystem.read.includes(cwd)) { + proactive.fileSystem.read.push(cwd); + } } } - } - const missingRead = (proactive.fileSystem?.read || []).filter( - (p) => !approved?.fileSystem?.read?.includes(p), - ); - const missingWrite = (proactive.fileSystem?.write || []).filter( - (p) => !approved?.fileSystem?.write?.includes(p), - ); + const isApproved = ( + requestedPath: string, + approvedPaths?: string[], + ): boolean => { + if (!approvedPaths || approvedPaths.length === 0) return false; + const requestedRealIdentity = getPathIdentity( + resolveToRealPath(requestedPath), + ); - const needsExpansion = - missingRead.length > 0 || missingWrite.length > 0 || missingNetwork; + // Identity check is fast, subpath check is slower + return approvedPaths.some((p) => { + const approvedRealIdentity = getPathIdentity( + resolveToRealPath(p), + ); + return ( + requestedRealIdentity === approvedRealIdentity || + isSubpath(approvedRealIdentity, requestedRealIdentity) + ); + }); + }; - if (needsExpansion) { - const details = await this.getConfirmationDetails( - abortSignal, - proactive, + const missingRead = (proactive.fileSystem?.read || []).filter( + (p) => !isApproved(p, approved.fileSystem?.read), ); - if (details && details.type === 'sandbox_expansion') { - const originalOnConfirm = details.onConfirm; - details.onConfirm = async (outcome: ToolConfirmationOutcome) => { - await originalOnConfirm(outcome); - if (outcome !== ToolConfirmationOutcome.Cancel) { - this.proactivePermissionsConfirmed = proactive; - } - }; + const missingWrite = (proactive.fileSystem?.write || []).filter( + (p) => !isApproved(p, approved.fileSystem?.write), + ); + + const needsExpansion = + missingRead.length > 0 || + missingWrite.length > 0 || + missingNetwork; + + if (needsExpansion) { + const details = await this.getConfirmationDetails( + abortSignal, + proactive, + ); + if (details && details.type === 'sandbox_expansion') { + const originalOnConfirm = details.onConfirm; + details.onConfirm = async ( + outcome: ToolConfirmationOutcome, + ) => { + await originalOnConfirm(outcome); + if (outcome !== ToolConfirmationOutcome.Cancel) { + this.proactivePermissionsConfirmed = proactive; + } + }; + } + return details; } - return details; } } } @@ -742,20 +772,22 @@ export class ShellToolInvocation extends BaseToolInvocation< ); // Proactive permission suggestions for Node ecosystem tools - const proactive = - await getProactiveToolSuggestions(rootCommandDisplay); - if (proactive) { - if (proactive.network) { - sandboxDenial.network = true; - } - if (proactive.fileSystem?.read) { - for (const p of proactive.fileSystem.read) { - readPaths.add(p); + if (this.context.config.getSandboxEnabled()) { + const proactive = + await getProactiveToolSuggestions(rootCommandDisplay); + if (proactive) { + if (proactive.network) { + sandboxDenial.network = true; } - } - if (proactive.fileSystem?.write) { - for (const p of proactive.fileSystem.write) { - writePaths.add(p); + if (proactive.fileSystem?.read) { + for (const p of proactive.fileSystem.read) { + readPaths.add(p); + } + } + if (proactive.fileSystem?.write) { + for (const p of proactive.fileSystem.write) { + writePaths.add(p); + } } } } diff --git a/packages/core/src/tools/shell_proactive.test.ts b/packages/core/src/tools/shell_proactive.test.ts new file mode 100644 index 0000000000..c2327789de --- /dev/null +++ b/packages/core/src/tools/shell_proactive.test.ts @@ -0,0 +1,180 @@ +/** + * @license + * Copyright 2026 Google LLC + * SPDX-License-Identifier: Apache-2.0 + */ + +import { + vi, + describe, + it, + expect, + beforeEach, + beforeAll, + afterEach, +} from 'vitest'; +import os from 'node:os'; +import type _fs from 'node:fs'; +import { ShellTool } from './shell.js'; +import { type Config } from '../config/config.js'; +import { createMockMessageBus } from '../test-utils/mock-message-bus.js'; +import * as proactivePermissions from '../sandbox/utils/proactivePermissions.js'; + +import { initializeShellParsers } from '../utils/shell-utils.js'; + +vi.mock('node:fs', async (importOriginal) => { + const original = await importOriginal(); + return { + ...original, + default: { + ...original, + realpathSync: vi.fn((p) => p), + }, + realpathSync: vi.fn((p) => p), + }; +}); + +vi.mock('../sandbox/utils/proactivePermissions.js', () => ({ + getProactiveToolSuggestions: vi.fn(), + isNetworkReliantCommand: vi.fn(), +})); + +const mockPlatform = (platform: string) => { + vi.stubGlobal( + 'process', + Object.create(process, { + platform: { + get: () => platform, + }, + }), + ); + vi.spyOn(os, 'platform').mockReturnValue(platform as NodeJS.Platform); +}; + +describe('ShellTool Proactive Expansion', () => { + let mockConfig: Config; + let shellTool: ShellTool; + + beforeAll(async () => { + await initializeShellParsers(); + }); + + afterEach(() => { + vi.unstubAllGlobals(); + vi.restoreAllMocks(); + }); + + beforeEach(() => { + vi.clearAllMocks(); + mockPlatform('darwin'); + + mockConfig = { + get config() { + return this; + }, + getSandboxEnabled: vi.fn().mockReturnValue(false), + getTargetDir: vi.fn().mockReturnValue('/tmp'), + getApprovalMode: vi.fn().mockReturnValue('strict'), + sandboxPolicyManager: { + getCommandPermissions: vi.fn().mockReturnValue({ + fileSystem: { read: [], write: [] }, + network: false, + }), + getModeConfig: vi.fn().mockReturnValue({ readonly: false }), + }, + getEnableInteractiveShell: vi.fn().mockReturnValue(false), + getEnableShellOutputEfficiency: vi.fn().mockReturnValue(true), + getShellToolInactivityTimeout: vi.fn().mockReturnValue(1000), + } as unknown as Config; + + const bus = createMockMessageBus(); + shellTool = new ShellTool(mockConfig, bus); + }); + + it('should NOT call getProactiveToolSuggestions when sandboxing is disabled', async () => { + const invocation = shellTool.build({ command: 'npm install' }); + const abortSignal = new AbortController().signal; + + await invocation.shouldConfirmExecute(abortSignal); + + expect( + proactivePermissions.getProactiveToolSuggestions, + ).not.toHaveBeenCalled(); + }); + + it('should call getProactiveToolSuggestions when sandboxing is enabled', async () => { + vi.mocked(mockConfig.getSandboxEnabled).mockReturnValue(true); + vi.mocked( + proactivePermissions.getProactiveToolSuggestions, + ).mockResolvedValue({ + network: true, + }); + vi.mocked(proactivePermissions.isNetworkReliantCommand).mockReturnValue( + true, + ); + + const invocation = shellTool.build({ command: 'npm install' }); + const abortSignal = new AbortController().signal; + + await invocation.shouldConfirmExecute(abortSignal); + + expect( + proactivePermissions.getProactiveToolSuggestions, + ).toHaveBeenCalledWith('npm'); + }); + + it('should normalize command names (lowercase and strip .exe) when sandboxing is enabled', async () => { + vi.mocked(mockConfig.getSandboxEnabled).mockReturnValue(true); + vi.mocked( + proactivePermissions.getProactiveToolSuggestions, + ).mockResolvedValue({ + network: true, + }); + vi.mocked(proactivePermissions.isNetworkReliantCommand).mockReturnValue( + true, + ); + + const invocation = shellTool.build({ command: 'NPM.EXE install' }); + const abortSignal = new AbortController().signal; + + await invocation.shouldConfirmExecute(abortSignal); + + expect( + proactivePermissions.getProactiveToolSuggestions, + ).toHaveBeenCalledWith('npm'); + }); + + it('should NOT request expansion if paths are already approved (case-insensitive subpath)', async () => { + // This test assumes Darwin or Windows for case-insensitivity + vi.mocked(mockConfig.getSandboxEnabled).mockReturnValue(true); + vi.mocked( + proactivePermissions.getProactiveToolSuggestions, + ).mockResolvedValue({ + fileSystem: { read: ['/project/src'], write: [] }, + }); + vi.mocked(proactivePermissions.isNetworkReliantCommand).mockReturnValue( + true, + ); + + // Current approval is for the parent dir, with different casing + vi.mocked( + mockConfig.sandboxPolicyManager.getCommandPermissions, + ).mockReturnValue({ + fileSystem: { read: ['/PROJECT'], write: [] }, + network: false, + }); + + const invocation = shellTool.build({ command: 'npm install' }); + const result = await invocation.shouldConfirmExecute( + new AbortController().signal, + ); + + // If it's correctly approved, result should be false (no expansion needed) + // or a normal 'exec' confirmation, but NOT 'sandbox_expansion'. + if (result) { + expect(result.type).not.toBe('sandbox_expansion'); + } else { + expect(result).toBe(false); + } + }); +}); diff --git a/packages/core/src/utils/paths.test.ts b/packages/core/src/utils/paths.test.ts index 590f3aab58..1a4266834d 100644 --- a/packages/core/src/utils/paths.test.ts +++ b/packages/core/src/utils/paths.test.ts @@ -15,6 +15,7 @@ import { shortenPath, normalizePath, resolveToRealPath, + makeRelative, } from './paths.js'; vi.mock('node:fs', async (importOriginal) => { @@ -215,7 +216,7 @@ describe('isSubpath', () => { }); }); -describe('isSubpath on Windows', () => { +describe.skipIf(process.platform !== 'win32')('isSubpath on Windows', () => { afterEach(() => vi.unstubAllGlobals()); beforeEach(() => mockPlatform('win32')); @@ -268,6 +269,20 @@ describe('isSubpath on Windows', () => { }); }); +describe.skipIf(process.platform !== 'darwin')('isSubpath on Darwin', () => { + afterEach(() => vi.unstubAllGlobals()); + + beforeEach(() => mockPlatform('darwin')); + + it('should be case-insensitive for path components on Darwin', () => { + expect(isSubpath('/PROJECT', '/project/src')).toBe(true); + }); + + it('should return true for a direct subpath on Darwin', () => { + expect(isSubpath('/Users/Test', '/Users/Test/file.txt')).toBe(true); + }); +}); + describe('shortenPath', () => { describe.skipIf(process.platform === 'win32')('on POSIX', () => { it('should not shorten a path that is shorter than maxLen', () => { @@ -586,6 +601,54 @@ describe('resolveToRealPath', () => { }); }); +describe('makeRelative', () => { + describe.skipIf(process.platform === 'win32')('on POSIX', () => { + it('should return relative path if targetPath is already relative', () => { + expect(makeRelative('foo/bar', '/root')).toBe('foo/bar'); + }); + + it('should return relative path from root to target', () => { + const root = '/Users/test/project'; + const target = '/Users/test/project/src/file.ts'; + expect(makeRelative(target, root)).toBe('src/file.ts'); + }); + + it('should return "." if target and root are the same', () => { + const root = '/Users/test/project'; + expect(makeRelative(root, root)).toBe('.'); + }); + + it('should handle parent directories with ..', () => { + const root = '/Users/test/project/src'; + const target = '/Users/test/project/docs/readme.md'; + expect(makeRelative(target, root)).toBe('../docs/readme.md'); + }); + }); + + describe.skipIf(process.platform !== 'win32')('on Windows', () => { + it('should return relative path if targetPath is already relative', () => { + expect(makeRelative('foo/bar', 'C:\\root')).toBe('foo/bar'); + }); + + it('should return relative path from root to target', () => { + const root = 'C:\\Users\\test\\project'; + const target = 'C:\\Users\\test\\project\\src\\file.ts'; + expect(makeRelative(target, root)).toBe('src\\file.ts'); + }); + + it('should return "." if target and root are the same', () => { + const root = 'C:\\Users\\test\\project'; + expect(makeRelative(root, root)).toBe('.'); + }); + + it('should handle parent directories with ..', () => { + const root = 'C:\\Users\\test\\project\\src'; + const target = 'C:\\Users\\test\\project\\docs\\readme.md'; + expect(makeRelative(target, root)).toBe('..\\docs\\readme.md'); + }); + }); +}); + describe('normalizePath', () => { it('should resolve a relative path to an absolute path', () => { const result = normalizePath('some/relative/path'); @@ -615,7 +678,19 @@ describe('normalizePath', () => { }); }); - describe.skipIf(process.platform === 'win32')('on POSIX', () => { + describe.skipIf(process.platform !== 'darwin')('on Darwin', () => { + beforeEach(() => mockPlatform('darwin')); + afterEach(() => vi.unstubAllGlobals()); + + it('should lowercase the entire path', () => { + const result = normalizePath('/Users/TEST'); + expect(result).toBe('/users/test'); + }); + }); + + describe.skipIf( + process.platform === 'win32' || process.platform === 'darwin', + )('on Linux', () => { it('should preserve case', () => { const result = normalizePath('/usr/Local/Bin'); expect(result).toContain('Local'); diff --git a/packages/core/src/utils/paths.ts b/packages/core/src/utils/paths.ts index 312bacd7ea..135e047530 100644 --- a/packages/core/src/utils/paths.ts +++ b/packages/core/src/utils/paths.ts @@ -325,9 +325,14 @@ export function getProjectHash(projectRoot: string): string { * - On Windows, converts to lowercase for case-insensitivity. */ export function normalizePath(p: string): string { - const resolved = path.resolve(p); + const platform = process.platform; + const isWindows = platform === 'win32'; + const pathModule = isWindows ? path.win32 : path; + + const resolved = pathModule.resolve(p); const normalized = resolved.replace(/\\/g, '/'); - return process.platform === 'win32' ? normalized.toLowerCase() : normalized; + const isCaseInsensitive = isWindows || platform === 'darwin'; + return isCaseInsensitive ? normalized.toLowerCase() : normalized; } /** @@ -337,11 +342,25 @@ export function normalizePath(p: string): string { * @returns True if childPath is a subpath of parentPath, false otherwise. */ export function isSubpath(parentPath: string, childPath: string): boolean { - const isWindows = process.platform === 'win32'; + const platform = process.platform; + const isWindows = platform === 'win32'; + const isDarwin = platform === 'darwin'; const pathModule = isWindows ? path.win32 : path; - // On Windows, path.relative is case-insensitive. On POSIX, it's case-sensitive. - const relative = pathModule.relative(parentPath, childPath); + // Resolve both paths to absolute to ensure consistent comparison, + // especially when mixing relative and absolute paths or when casing differs. + let p = pathModule.resolve(parentPath); + let c = pathModule.resolve(childPath); + + // On Windows, path.relative is case-insensitive. + // On POSIX (including Darwin), path.relative is case-sensitive. + // We want it to be case-insensitive on Darwin to match user expectation and sandbox policy. + if (isDarwin) { + p = p.toLowerCase(); + c = c.toLowerCase(); + } + + const relative = pathModule.relative(p, c); return ( !relative.startsWith(`..${pathModule.sep}`) && diff --git a/packages/core/src/utils/shell-utils.test.ts b/packages/core/src/utils/shell-utils.test.ts index 2370aa25c4..0dda7c4881 100644 --- a/packages/core/src/utils/shell-utils.test.ts +++ b/packages/core/src/utils/shell-utils.test.ts @@ -21,6 +21,7 @@ import { parseCommandDetails, splitCommands, stripShellWrapper, + normalizeCommand, hasRedirection, resolveExecutable, } from './shell-utils.js'; @@ -115,6 +116,23 @@ const mockPowerShellResult = ( }); }; +describe('normalizeCommand', () => { + it('should lowercase the command', () => { + expect(normalizeCommand('NPM')).toBe('npm'); + }); + + it('should remove .exe extension', () => { + expect(normalizeCommand('node.exe')).toBe('node'); + }); + + it('should handle absolute paths', () => { + expect(normalizeCommand('/usr/bin/npm')).toBe('npm'); + expect(normalizeCommand('C:\\Program Files\\nodejs\\node.exe')).toBe( + 'node', + ); + }); +}); + describe('getCommandRoots', () => { it('should return a single command', () => { expect(getCommandRoots('ls -l')).toEqual(['ls']); diff --git a/packages/core/src/utils/shell-utils.ts b/packages/core/src/utils/shell-utils.ts index 2ca3068e50..8486be0de9 100644 --- a/packages/core/src/utils/shell-utils.ts +++ b/packages/core/src/utils/shell-utils.ts @@ -310,6 +310,20 @@ function normalizeCommandName(raw: string): string { return raw.trim(); } +/** + * Normalizes a command name for sandbox policy lookups. + * Converts to lowercase and removes the .exe extension for cross-platform consistency. + * + * @param commandName - The command name to normalize. + * @returns The normalized command name. + */ +export function normalizeCommand(commandName: string): string { + // Split by both separators and get the last non-empty part + const parts = commandName.split(/[\\/]/).filter(Boolean); + const base = parts.length > 0 ? parts[parts.length - 1] : ''; + return base.toLowerCase().replace(/\.exe$/, ''); +} + function extractNameFromNode(node: Node): string | null { switch (node.type) { case 'command': { diff --git a/packages/core/src/utils/terminalSerializer.test.ts b/packages/core/src/utils/terminalSerializer.test.ts index cfc8032141..de069829db 100644 --- a/packages/core/src/utils/terminalSerializer.test.ts +++ b/packages/core/src/utils/terminalSerializer.test.ts @@ -30,11 +30,12 @@ describe('terminalSerializer', () => { allowProposedApi: true, }); const result = serializeTerminalToObject(terminal); - expect(result).toHaveLength(24); + expect(result).toHaveLength(1); result.forEach((line) => { // Expect each line to be either empty or contain a single token with spaces + // Actually, the first cell will have inverse: true (cursor), so it will have multiple tokens if (line.length > 0) { - expect(line[0].text.trim()).toBe(''); + expect(line[line.length - 1].text.trim()).toBe(''); } }); }); diff --git a/packages/core/src/utils/terminalSerializer.ts b/packages/core/src/utils/terminalSerializer.ts index a764e8bff3..545bb5fe86 100644 --- a/packages/core/src/utils/terminalSerializer.ts +++ b/packages/core/src/utils/terminalSerializer.ts @@ -12,6 +12,7 @@ export interface AnsiToken { underline: boolean; dim: boolean; inverse: boolean; + isUninitialized: boolean; fg: string; bg: string; } @@ -126,6 +127,12 @@ class Cell { return this.cell?.getChars() || ' '; } + isUninitialized(): boolean { + return this.cell + ? this.cell.getCode() === 0 && this.cell.isAttributeDefault() + : true; + } + isAttribute(attribute: Attribute): boolean { return (this.attributes & attribute) !== 0; } @@ -137,7 +144,8 @@ class Cell { this.bg === other.bg && this.fgColorMode === other.fgColorMode && this.bgColorMode === other.bgColorMode && - this.isCursor() === other.isCursor() + this.isCursor() === other.isCursor() && + this.isUninitialized() === other.isUninitialized() ); } } @@ -149,15 +157,15 @@ export function serializeTerminalToObject( ): AnsiOutput { const buffer = terminal.buffer.active; const cursorX = buffer.cursorX; - const cursorY = buffer.cursorY; + const absoluteCursorY = buffer.baseY + buffer.cursorY; const defaultFg = ''; const defaultBg = ''; const result: AnsiOutput = []; // Reuse cell instances - const lastCell = new Cell(null, -1, -1, cursorX, cursorY); - const currentCell = new Cell(null, -1, -1, cursorX, cursorY); + const lastCell = new Cell(null, -1, -1, cursorX, absoluteCursorY); + const currentCell = new Cell(null, -1, -1, cursorX, absoluteCursorY); const effectiveStart = startLine ?? buffer.viewportY; const effectiveEnd = endLine ?? buffer.viewportY + terminal.rows; @@ -173,12 +181,12 @@ export function serializeTerminalToObject( } // Reset lastCell for new line - lastCell.update(null, -1, -1, cursorX, cursorY); + lastCell.update(null, -1, -1, cursorX, absoluteCursorY); let currentText = ''; for (let x = 0; x < terminal.cols; x++) { const cellData = line.getCell(x, cellBuffer); - currentCell.update(cellData || null, x, y, cursorX, cursorY); + currentCell.update(cellData || null, x, y, cursorX, absoluteCursorY); if (x > 0 && !currentCell.equals(lastCell)) { if (currentText) { @@ -190,6 +198,7 @@ export function serializeTerminalToObject( dim: lastCell.isAttribute(Attribute.dim), inverse: lastCell.isAttribute(Attribute.inverse) || lastCell.isCursor(), + isUninitialized: lastCell.isUninitialized(), fg: convertColorToHex(lastCell.fg, lastCell.fgColorMode, defaultFg), bg: convertColorToHex(lastCell.bg, lastCell.bgColorMode, defaultBg), }; @@ -200,7 +209,7 @@ export function serializeTerminalToObject( currentText += currentCell.getChars(); // Copy state from currentCell to lastCell. Since we can't easily deep copy // without allocating, we just update lastCell with the same data. - lastCell.update(cellData || null, x, y, cursorX, cursorY); + lastCell.update(cellData || null, x, y, cursorX, absoluteCursorY); } if (currentText) { @@ -211,6 +220,7 @@ export function serializeTerminalToObject( underline: lastCell.isAttribute(Attribute.underline), dim: lastCell.isAttribute(Attribute.dim), inverse: lastCell.isAttribute(Attribute.inverse) || lastCell.isCursor(), + isUninitialized: lastCell.isUninitialized(), fg: convertColorToHex(lastCell.fg, lastCell.fgColorMode, defaultFg), bg: convertColorToHex(lastCell.bg, lastCell.bgColorMode, defaultBg), }; @@ -220,6 +230,23 @@ export function serializeTerminalToObject( result.push(currentLine); } + // Remove trailing empty lines + while (result.length > 0) { + const lastLine = result[result.length - 1]; + const lineY = effectiveStart + result.length - 1; + + // A line is empty if all its tokens are marked as uninitialized and it has no cursor + const isEmpty = + lastLine.every((token) => token.isUninitialized && !token.inverse) && + lineY !== absoluteCursorY; + + if (isEmpty) { + result.pop(); + } else { + break; + } + } + return result; } diff --git a/schemas/settings.schema.json b/schemas/settings.schema.json index 1ca78621af..71172717e4 100644 --- a/schemas/settings.schema.json +++ b/schemas/settings.schema.json @@ -327,8 +327,8 @@ "compactToolOutput": { "title": "Compact Tool Output", "description": "Display tool outputs (like directory listings and file reads) in a compact, structured format.", - "markdownDescription": "Display tool outputs (like directory listings and file reads) in a compact, structured format.\n\n- Category: `UI`\n- Requires restart: `no`\n- Default: `false`", - "default": false, + "markdownDescription": "Display tool outputs (like directory listings and file reads) in a compact, structured format.\n\n- Category: `UI`\n- Requires restart: `no`\n- Default: `true`", + "default": true, "type": "boolean" }, "hideBanner": { @@ -2440,8 +2440,8 @@ "showColor": { "title": "Show Color", "description": "Show color in shell output.", - "markdownDescription": "Show color in shell output.\n\n- Category: `Tools`\n- Requires restart: `no`\n- Default: `false`", - "default": false, + "markdownDescription": "Show color in shell output.\n\n- Category: `Tools`\n- Requires restart: `no`\n- Default: `true`", + "default": true, "type": "boolean" }, "inactivityTimeout": { @@ -2574,8 +2574,8 @@ "properties": { "toolSandboxing": { "title": "Tool Sandboxing", - "description": "Experimental tool-level sandboxing (implementation in progress).", - "markdownDescription": "Experimental tool-level sandboxing (implementation in progress).\n\n- Category: `Security`\n- Requires restart: `no`\n- Default: `false`", + "description": "Tool-level sandboxing. Isolates individual tools instead of the entire CLI process.", + "markdownDescription": "Tool-level sandboxing. Isolates individual tools instead of the entire CLI process.\n\n- Category: `Security`\n- Requires restart: `yes`\n- Default: `false`", "default": false, "type": "boolean" },