mirror of
https://github.com/QwenLM/qwen-code.git
synced 2026-05-05 15:31:27 +00:00
Merge branch 'main' into refactor/task-to-agent-tool
This commit is contained in:
tanzhenxin
commit
9d6aca8efe
160 changed files with 24692 additions and 1942 deletions
|
|
@ -39,6 +39,8 @@ import {
|
|||
getAllGeminiMdFilenames,
|
||||
ShellExecutionService,
|
||||
Storage,
|
||||
SessionEndReason,
|
||||
SessionStartSource,
|
||||
} from '@qwen-code/qwen-code-core';
|
||||
import { buildResumedHistoryItems } from './utils/resumeHistoryUtils.js';
|
||||
import { validateAuthMethod } from '../config/auth.js';
|
||||
|
|
@ -238,6 +240,10 @@ export const AppContainer = (props: AppContainerProps) => {
|
|||
const { codingPlanUpdateRequest, dismissCodingPlanUpdate } =
|
||||
useCodingPlanUpdates(settings, config, historyManager.addItem);
|
||||
|
||||
const [isTrustDialogOpen, setTrustDialogOpen] = useState(false);
|
||||
const openTrustDialog = useCallback(() => setTrustDialogOpen(true), []);
|
||||
const closeTrustDialog = useCallback(() => setTrustDialogOpen(false), []);
|
||||
|
||||
const [isPermissionsDialogOpen, setPermissionsDialogOpen] = useState(false);
|
||||
const openPermissionsDialog = useCallback(
|
||||
() => setPermissionsDialogOpen(true),
|
||||
|
|
@ -291,7 +297,42 @@ export const AppContainer = (props: AppContainerProps) => {
|
|||
);
|
||||
historyManager.loadHistory(historyItems);
|
||||
}
|
||||
|
||||
// Fire SessionStart event after config is initialized
|
||||
const sessionStartSource = resumedSessionData
|
||||
? SessionStartSource.Resume
|
||||
: SessionStartSource.Startup;
|
||||
|
||||
const hookSystem = config.getHookSystem();
|
||||
|
||||
if (hookSystem) {
|
||||
hookSystem
|
||||
.fireSessionStartEvent(sessionStartSource, config.getModel() ?? '')
|
||||
.then(() => {
|
||||
debugLogger.debug('SessionStart event completed successfully');
|
||||
})
|
||||
.catch((err) => {
|
||||
debugLogger.warn(`SessionStart hook failed: ${err}`);
|
||||
});
|
||||
} else {
|
||||
debugLogger.debug(
|
||||
'SessionStart: HookSystem not available, skipping event',
|
||||
);
|
||||
}
|
||||
})();
|
||||
|
||||
// Register SessionEnd cleanup for process exit
|
||||
registerCleanup(async () => {
|
||||
try {
|
||||
await config
|
||||
.getHookSystem()
|
||||
?.fireSessionEndEvent(SessionEndReason.PromptInputExit);
|
||||
debugLogger.debug('SessionEnd event completed successfully!!!');
|
||||
} catch (err) {
|
||||
debugLogger.error(`SessionEnd hook failed: ${err}`);
|
||||
}
|
||||
});
|
||||
|
||||
registerCleanup(async () => {
|
||||
const ideClient = await IdeClient.getInstance();
|
||||
await ideClient.disconnect();
|
||||
|
|
@ -513,6 +554,7 @@ export const AppContainer = (props: AppContainerProps) => {
|
|||
openEditorDialog,
|
||||
openSettingsDialog,
|
||||
openModelDialog,
|
||||
openTrustDialog,
|
||||
openArenaDialog,
|
||||
openPermissionsDialog,
|
||||
openApprovalModeDialog,
|
||||
|
|
@ -541,6 +583,7 @@ export const AppContainer = (props: AppContainerProps) => {
|
|||
openArenaDialog,
|
||||
setDebugMessage,
|
||||
dispatchExtensionStateUpdate,
|
||||
openTrustDialog,
|
||||
openPermissionsDialog,
|
||||
openApprovalModeDialog,
|
||||
addConfirmUpdateExtensionRequest,
|
||||
|
|
@ -1071,6 +1114,7 @@ export const AppContainer = (props: AppContainerProps) => {
|
|||
streamingState,
|
||||
elapsedTime,
|
||||
settings,
|
||||
config,
|
||||
});
|
||||
|
||||
// Dialog close functionality
|
||||
|
|
@ -1345,6 +1389,7 @@ export const AppContainer = (props: AppContainerProps) => {
|
|||
isThemeDialogOpen ||
|
||||
isSettingsDialogOpen ||
|
||||
isModelDialogOpen ||
|
||||
isTrustDialogOpen ||
|
||||
activeArenaDialog !== null ||
|
||||
isPermissionsDialogOpen ||
|
||||
isAuthDialogOpen ||
|
||||
|
|
@ -1396,6 +1441,7 @@ export const AppContainer = (props: AppContainerProps) => {
|
|||
quittingMessages,
|
||||
isSettingsDialogOpen,
|
||||
isModelDialogOpen,
|
||||
isTrustDialogOpen,
|
||||
activeArenaDialog,
|
||||
isPermissionsDialogOpen,
|
||||
isApprovalModeDialogOpen,
|
||||
|
|
@ -1492,6 +1538,7 @@ export const AppContainer = (props: AppContainerProps) => {
|
|||
quittingMessages,
|
||||
isSettingsDialogOpen,
|
||||
isModelDialogOpen,
|
||||
isTrustDialogOpen,
|
||||
activeArenaDialog,
|
||||
isPermissionsDialogOpen,
|
||||
isApprovalModeDialogOpen,
|
||||
|
|
@ -1595,6 +1642,7 @@ export const AppContainer = (props: AppContainerProps) => {
|
|||
closeArenaDialog,
|
||||
handleArenaModelsSelected,
|
||||
dismissCodingPlanUpdate,
|
||||
closeTrustDialog,
|
||||
closePermissionsDialog,
|
||||
setShellModeActive,
|
||||
vimHandleInput,
|
||||
|
|
@ -1647,6 +1695,7 @@ export const AppContainer = (props: AppContainerProps) => {
|
|||
closeArenaDialog,
|
||||
handleArenaModelsSelected,
|
||||
dismissCodingPlanUpdate,
|
||||
closeTrustDialog,
|
||||
closePermissionsDialog,
|
||||
setShellModeActive,
|
||||
vimHandleInput,
|
||||
|
|
|
|||
|
|
@ -8,6 +8,10 @@ import { vi, describe, it, expect, beforeEach } from 'vitest';
|
|||
import { clearCommand } from './clearCommand.js';
|
||||
import { type CommandContext } from './types.js';
|
||||
import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
|
||||
import {
|
||||
SessionEndReason,
|
||||
SessionStartSource,
|
||||
} from '@qwen-code/qwen-code-core';
|
||||
|
||||
// Mock the telemetry service
|
||||
vi.mock('@qwen-code/qwen-code-core', async () => {
|
||||
|
|
@ -26,10 +30,19 @@ describe('clearCommand', () => {
|
|||
let mockContext: CommandContext;
|
||||
let mockResetChat: ReturnType<typeof vi.fn>;
|
||||
let mockStartNewSession: ReturnType<typeof vi.fn>;
|
||||
let mockFireSessionEndEvent: ReturnType<typeof vi.fn>;
|
||||
let mockFireSessionStartEvent: ReturnType<typeof vi.fn>;
|
||||
let mockGetHookSystem: ReturnType<typeof vi.fn>;
|
||||
|
||||
beforeEach(() => {
|
||||
mockResetChat = vi.fn().mockResolvedValue(undefined);
|
||||
mockStartNewSession = vi.fn().mockReturnValue('new-session-id');
|
||||
mockFireSessionEndEvent = vi.fn().mockResolvedValue(undefined);
|
||||
mockFireSessionStartEvent = vi.fn().mockResolvedValue(undefined);
|
||||
mockGetHookSystem = vi.fn().mockReturnValue({
|
||||
fireSessionEndEvent: mockFireSessionEndEvent,
|
||||
fireSessionStartEvent: mockFireSessionStartEvent,
|
||||
});
|
||||
vi.clearAllMocks();
|
||||
|
||||
mockContext = createMockCommandContext({
|
||||
|
|
@ -40,6 +53,11 @@ describe('clearCommand', () => {
|
|||
resetChat: mockResetChat,
|
||||
}) as unknown as GeminiClient,
|
||||
startNewSession: mockStartNewSession,
|
||||
getHookSystem: mockGetHookSystem,
|
||||
getDebugLogger: () => ({
|
||||
warn: vi.fn(),
|
||||
}),
|
||||
getModel: () => 'test-model',
|
||||
getToolRegistry: () => undefined,
|
||||
},
|
||||
},
|
||||
|
|
@ -76,6 +94,50 @@ describe('clearCommand', () => {
|
|||
expect(mockContext.ui.clear).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should fire SessionEnd event before clearing and SessionStart event after clearing', async () => {
|
||||
if (!clearCommand.action) {
|
||||
throw new Error('clearCommand must have an action.');
|
||||
}
|
||||
|
||||
await clearCommand.action(mockContext, '');
|
||||
|
||||
expect(mockGetHookSystem).toHaveBeenCalled();
|
||||
expect(mockFireSessionEndEvent).toHaveBeenCalledWith(
|
||||
SessionEndReason.Clear,
|
||||
);
|
||||
expect(mockFireSessionStartEvent).toHaveBeenCalledWith(
|
||||
SessionStartSource.Clear,
|
||||
'test-model',
|
||||
);
|
||||
|
||||
// SessionEnd should be called before SessionStart
|
||||
const sessionEndCallOrder =
|
||||
mockFireSessionEndEvent.mock.invocationCallOrder[0];
|
||||
const sessionStartCallOrder =
|
||||
mockFireSessionStartEvent.mock.invocationCallOrder[0];
|
||||
expect(sessionEndCallOrder).toBeLessThan(sessionStartCallOrder);
|
||||
});
|
||||
|
||||
it('should handle hook errors gracefully and continue execution', async () => {
|
||||
if (!clearCommand.action) {
|
||||
throw new Error('clearCommand must have an action.');
|
||||
}
|
||||
|
||||
mockFireSessionEndEvent.mockRejectedValue(
|
||||
new Error('SessionEnd hook failed'),
|
||||
);
|
||||
mockFireSessionStartEvent.mockRejectedValue(
|
||||
new Error('SessionStart hook failed'),
|
||||
);
|
||||
|
||||
await clearCommand.action(mockContext, '');
|
||||
|
||||
// Should still complete the clear operation despite hook errors
|
||||
expect(mockStartNewSession).toHaveBeenCalledTimes(1);
|
||||
expect(mockResetChat).toHaveBeenCalledTimes(1);
|
||||
expect(mockContext.ui.clear).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('should not attempt to reset chat if config service is not available', async () => {
|
||||
if (!clearCommand.action) {
|
||||
throw new Error('clearCommand must have an action.');
|
||||
|
|
|
|||
|
|
@ -9,6 +9,8 @@ import { CommandKind } from './types.js';
|
|||
import { t } from '../../i18n/index.js';
|
||||
import {
|
||||
uiTelemetryService,
|
||||
SessionEndReason,
|
||||
SessionStartSource,
|
||||
ToolNames,
|
||||
SkillTool,
|
||||
} from '@qwen-code/qwen-code-core';
|
||||
|
|
@ -24,6 +26,15 @@ export const clearCommand: SlashCommand = {
|
|||
const { config } = context.services;
|
||||
|
||||
if (config) {
|
||||
// Fire SessionEnd event before clearing (current session ends)
|
||||
try {
|
||||
await config
|
||||
.getHookSystem()
|
||||
?.fireSessionEndEvent(SessionEndReason.Clear);
|
||||
} catch (err) {
|
||||
config.getDebugLogger().warn(`SessionEnd hook failed: ${err}`);
|
||||
}
|
||||
|
||||
const newSessionId = config.startNewSession();
|
||||
|
||||
// Reset UI telemetry metrics for the new session
|
||||
|
|
@ -53,6 +64,18 @@ export const clearCommand: SlashCommand = {
|
|||
} else {
|
||||
context.ui.setDebugMessage(t('Starting a new session and clearing.'));
|
||||
}
|
||||
|
||||
// Fire SessionStart event after clearing (new session starts)
|
||||
try {
|
||||
await config
|
||||
.getHookSystem()
|
||||
?.fireSessionStartEvent(
|
||||
SessionStartSource.Clear,
|
||||
config.getModel() ?? '',
|
||||
);
|
||||
} catch (err) {
|
||||
config.getDebugLogger().warn(`SessionStart hook failed: ${err}`);
|
||||
}
|
||||
} else {
|
||||
context.ui.setDebugMessage(t('Starting a new session and clearing.'));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@
|
|||
import type { SlashCommand, CommandContext } from './types.js';
|
||||
import { CommandKind } from './types.js';
|
||||
import { MessageType } from '../types.js';
|
||||
import * as fs from 'node:fs';
|
||||
import * as os from 'node:os';
|
||||
import * as path from 'node:path';
|
||||
import { loadServerHierarchicalMemory } from '@qwen-code/qwen-code-core';
|
||||
|
|
@ -25,6 +26,44 @@ export function expandHomeDir(p: string): string {
|
|||
return path.normalize(expandedPath);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns directory path completions for the given partial argument.
|
||||
* Supports comma-separated paths by completing only the last segment.
|
||||
*/
|
||||
export function getDirPathCompletions(partialArg: string): string[] {
|
||||
const lastComma = partialArg.lastIndexOf(',');
|
||||
const prefix = lastComma >= 0 ? partialArg.substring(0, lastComma + 1) : '';
|
||||
const partial =
|
||||
lastComma >= 0
|
||||
? partialArg.substring(lastComma + 1).trimStart()
|
||||
: partialArg;
|
||||
|
||||
const trimmed = partial.trim();
|
||||
if (!trimmed) return [];
|
||||
|
||||
const expanded = trimmed.startsWith('~')
|
||||
? trimmed.replace(/^~/, os.homedir())
|
||||
: trimmed;
|
||||
const endsWithSep = expanded.endsWith('/') || expanded.endsWith(path.sep);
|
||||
const searchDir = endsWithSep ? expanded : path.dirname(expanded);
|
||||
const namePrefix = endsWithSep ? '' : path.basename(expanded);
|
||||
|
||||
try {
|
||||
return fs
|
||||
.readdirSync(searchDir, { withFileTypes: true })
|
||||
.filter(
|
||||
(e) =>
|
||||
e.isDirectory() &&
|
||||
e.name.startsWith(namePrefix) &&
|
||||
!e.name.startsWith('.'),
|
||||
)
|
||||
.map((e) => prefix + path.join(searchDir, e.name))
|
||||
.slice(0, 8);
|
||||
} catch {
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
export const directoryCommand: SlashCommand = {
|
||||
name: 'directory',
|
||||
altNames: ['dir'],
|
||||
|
|
@ -41,6 +80,8 @@ export const directoryCommand: SlashCommand = {
|
|||
);
|
||||
},
|
||||
kind: CommandKind.BUILT_IN,
|
||||
completion: async (_context: CommandContext, partialArg: string) =>
|
||||
getDirPathCompletions(partialArg),
|
||||
action: async (context: CommandContext, args: string) => {
|
||||
const {
|
||||
ui: { addItem },
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ describe('permissionsCommand', () => {
|
|||
|
||||
it('should have the correct name and description', () => {
|
||||
expect(permissionsCommand.name).toBe('permissions');
|
||||
expect(permissionsCommand.description).toBe('Manage folder trust settings');
|
||||
expect(permissionsCommand.description).toBe('Manage permission rules');
|
||||
});
|
||||
|
||||
it('should be a built-in command', () => {
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ import { t } from '../../i18n/index.js';
|
|||
export const permissionsCommand: SlashCommand = {
|
||||
name: 'permissions',
|
||||
get description() {
|
||||
return t('Manage folder trust settings');
|
||||
return t('Manage permission rules');
|
||||
},
|
||||
kind: CommandKind.BUILT_IN,
|
||||
action: (): OpenDialogActionReturn => ({
|
||||
|
|
|
|||
35
packages/cli/src/ui/commands/trustCommand.test.ts
Normal file
35
packages/cli/src/ui/commands/trustCommand.test.ts
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
/**
|
||||
* @license
|
||||
* Copyright 2025 Google LLC
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
import { describe, it, expect, beforeEach } from 'vitest';
|
||||
import { trustCommand } from './trustCommand.js';
|
||||
import { type CommandContext, CommandKind } from './types.js';
|
||||
import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
|
||||
|
||||
describe('trustCommand', () => {
|
||||
let mockContext: CommandContext;
|
||||
|
||||
beforeEach(() => {
|
||||
mockContext = createMockCommandContext();
|
||||
});
|
||||
|
||||
it('should have the correct name and description', () => {
|
||||
expect(trustCommand.name).toBe('trust');
|
||||
expect(trustCommand.description).toBe('Manage folder trust settings');
|
||||
});
|
||||
|
||||
it('should be a built-in command', () => {
|
||||
expect(trustCommand.kind).toBe(CommandKind.BUILT_IN);
|
||||
});
|
||||
|
||||
it('should return an action to open the trust dialog', () => {
|
||||
const actionResult = trustCommand.action?.(mockContext, '');
|
||||
expect(actionResult).toEqual({
|
||||
type: 'dialog',
|
||||
dialog: 'trust',
|
||||
});
|
||||
});
|
||||
});
|
||||
21
packages/cli/src/ui/commands/trustCommand.ts
Normal file
21
packages/cli/src/ui/commands/trustCommand.ts
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
/**
|
||||
* @license
|
||||
* Copyright 2025 Google LLC
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
import type { OpenDialogActionReturn, SlashCommand } from './types.js';
|
||||
import { CommandKind } from './types.js';
|
||||
import { t } from '../../i18n/index.js';
|
||||
|
||||
export const trustCommand: SlashCommand = {
|
||||
name: 'trust',
|
||||
get description() {
|
||||
return t('Manage folder trust settings');
|
||||
},
|
||||
kind: CommandKind.BUILT_IN,
|
||||
action: (): OpenDialogActionReturn => ({
|
||||
type: 'dialog',
|
||||
dialog: 'trust',
|
||||
}),
|
||||
};
|
||||
|
|
@ -150,6 +150,7 @@ export interface OpenDialogActionReturn {
|
|||
| 'model'
|
||||
| 'subagent_create'
|
||||
| 'subagent_list'
|
||||
| 'trust'
|
||||
| 'permissions'
|
||||
| 'approval-mode'
|
||||
| 'resume'
|
||||
|
|
|
|||
|
|
@ -18,7 +18,8 @@ import { SettingsDialog } from './SettingsDialog.js';
|
|||
import { QwenOAuthProgress } from './QwenOAuthProgress.js';
|
||||
import { AuthDialog } from '../auth/AuthDialog.js';
|
||||
import { EditorSettingsDialog } from './EditorSettingsDialog.js';
|
||||
import { PermissionsModifyTrustDialog } from './PermissionsModifyTrustDialog.js';
|
||||
import { TrustDialog } from './TrustDialog.js';
|
||||
import { PermissionsDialog } from './PermissionsDialog.js';
|
||||
import { ModelDialog } from './ModelDialog.js';
|
||||
import { ArenaStartDialog } from './arena/ArenaStartDialog.js';
|
||||
import { ArenaSelectDialog } from './arena/ArenaSelectDialog.js';
|
||||
|
|
@ -314,15 +315,16 @@ export const DialogManager = ({
|
|||
);
|
||||
}
|
||||
}
|
||||
if (uiState.isPermissionsDialogOpen) {
|
||||
if (uiState.isTrustDialogOpen) {
|
||||
return (
|
||||
<PermissionsModifyTrustDialog
|
||||
onExit={uiActions.closePermissionsDialog}
|
||||
addItem={addItem}
|
||||
/>
|
||||
<TrustDialog onExit={uiActions.closeTrustDialog} addItem={addItem} />
|
||||
);
|
||||
}
|
||||
|
||||
if (uiState.isPermissionsDialogOpen) {
|
||||
return <PermissionsDialog onExit={uiActions.closePermissionsDialog} />;
|
||||
}
|
||||
|
||||
if (uiState.isSubagentCreateDialogOpen) {
|
||||
return (
|
||||
<AgentCreationWizard
|
||||
|
|
|
|||
986
packages/cli/src/ui/components/PermissionsDialog.tsx
Normal file
986
packages/cli/src/ui/components/PermissionsDialog.tsx
Normal file
|
|
@ -0,0 +1,986 @@
|
|||
/**
|
||||
* @license
|
||||
* Copyright 2025 Google LLC
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
import type React from 'react';
|
||||
import { useCallback, useEffect, useMemo, useState } from 'react';
|
||||
import { Box, Text } from 'ink';
|
||||
import * as fs from 'node:fs';
|
||||
import * as os from 'node:os';
|
||||
import * as nodePath from 'node:path';
|
||||
import { theme } from '../semantic-colors.js';
|
||||
import { useKeypress } from '../hooks/useKeypress.js';
|
||||
import { RadioButtonSelect } from './shared/RadioButtonSelect.js';
|
||||
import { useConfig } from '../contexts/ConfigContext.js';
|
||||
import { useSettings } from '../contexts/SettingsContext.js';
|
||||
import { SettingScope } from '../../config/settings.js';
|
||||
import { TextInput } from './shared/TextInput.js';
|
||||
import { Colors } from '../colors.js';
|
||||
import { t } from '../../i18n/index.js';
|
||||
import type {
|
||||
PermissionManager,
|
||||
RuleWithSource,
|
||||
RuleType,
|
||||
} from '@qwen-code/qwen-code-core';
|
||||
import { isPathWithinRoot } from '@qwen-code/qwen-code-core';
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Types
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
type TabId = 'allow' | 'ask' | 'deny' | 'workspace';
|
||||
|
||||
interface Tab {
|
||||
id: TabId;
|
||||
label: string;
|
||||
description: string;
|
||||
}
|
||||
|
||||
/** Internal views for the dialog state machine. */
|
||||
type DialogView =
|
||||
| 'rule-list' // main rule list view
|
||||
| 'add-rule-input' // text input for new rule
|
||||
| 'add-rule-scope' // scope selector after entering a rule
|
||||
| 'delete-confirm' // confirm rule deletion
|
||||
| 'ws-dir-list' // workspace directory list
|
||||
| 'ws-add-dir-input' // text input for adding a directory
|
||||
| 'ws-remove-confirm'; // confirm directory removal
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Scope items (matches Claude Code screenshot layout)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
interface PermScopeItem {
|
||||
label: string;
|
||||
description: string;
|
||||
value: SettingScope;
|
||||
key: string;
|
||||
}
|
||||
|
||||
function getPermScopeItems(): PermScopeItem[] {
|
||||
return [
|
||||
{
|
||||
label: t('Project settings'),
|
||||
description: t('Checked in at .qwen/settings.json'),
|
||||
value: SettingScope.Workspace,
|
||||
key: 'project',
|
||||
},
|
||||
{
|
||||
label: t('User settings'),
|
||||
description: t('Saved in at ~/.qwen/settings.json'),
|
||||
value: SettingScope.User,
|
||||
key: 'user',
|
||||
},
|
||||
];
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function getTabs(): Tab[] {
|
||||
return [
|
||||
{
|
||||
id: 'allow',
|
||||
label: t('Allow'),
|
||||
description: t("Qwen Code won't ask before using allowed tools."),
|
||||
},
|
||||
{
|
||||
id: 'ask',
|
||||
label: t('Ask'),
|
||||
description: t('Qwen Code will ask before using these tools.'),
|
||||
},
|
||||
{
|
||||
id: 'deny',
|
||||
label: t('Deny'),
|
||||
description: t('Qwen Code is not allowed to use denied tools.'),
|
||||
},
|
||||
{
|
||||
id: 'workspace',
|
||||
label: t('Workspace'),
|
||||
description: t('Manage trusted directories for this workspace.'),
|
||||
},
|
||||
];
|
||||
}
|
||||
|
||||
function describeRule(raw: string): string {
|
||||
const match = raw.match(/^([^(]+?)(?:\((.+)\))?$/);
|
||||
if (!match) return raw;
|
||||
const toolName = match[1]!.trim();
|
||||
const specifier = match[2]?.trim();
|
||||
if (!specifier) {
|
||||
return t('Any use of the {{tool}} tool', { tool: toolName });
|
||||
}
|
||||
return t("{{tool}} commands matching '{{pattern}}'", {
|
||||
tool: toolName,
|
||||
pattern: specifier,
|
||||
});
|
||||
}
|
||||
|
||||
function scopeLabel(scope: string): string {
|
||||
switch (scope) {
|
||||
case 'user':
|
||||
return t('From user settings');
|
||||
case 'workspace':
|
||||
return t('From project settings');
|
||||
case 'session':
|
||||
return t('From session');
|
||||
default:
|
||||
return scope;
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Component props
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
interface PermissionsDialogProps {
|
||||
onExit: () => void;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Main component
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export function PermissionsDialog({
|
||||
onExit,
|
||||
}: PermissionsDialogProps): React.JSX.Element {
|
||||
const config = useConfig();
|
||||
const settings = useSettings();
|
||||
const pm = config.getPermissionManager?.() as PermissionManager | null;
|
||||
|
||||
// --- Tab state ---
|
||||
const tabs = useMemo(() => getTabs(), []);
|
||||
const [activeTabIndex, setActiveTabIndex] = useState(0);
|
||||
const activeTab = tabs[activeTabIndex]!;
|
||||
|
||||
// --- Rule list state ---
|
||||
const [allRules, setAllRules] = useState<RuleWithSource[]>([]);
|
||||
const [searchQuery, setSearchQuery] = useState('');
|
||||
const [isSearchActive, setIsSearchActive] = useState(false);
|
||||
|
||||
// --- Dialog view state machine ---
|
||||
const [view, setView] = useState<DialogView>('rule-list');
|
||||
const [newRuleInput, setNewRuleInput] = useState('');
|
||||
const [pendingRuleText, setPendingRuleText] = useState('');
|
||||
const [deleteTarget, setDeleteTarget] = useState<RuleWithSource | null>(null);
|
||||
|
||||
// --- Workspace directory state ---
|
||||
const workspaceContext = config.getWorkspaceContext();
|
||||
const [newDirInput, setNewDirInput] = useState('');
|
||||
const [dirInputError, setDirInputError] = useState('');
|
||||
const [dirInputRemountKey, setDirInputRemountKey] = useState(0);
|
||||
const [completionIndex, setCompletionIndex] = useState(0);
|
||||
const [removeDirTarget, setRemoveDirTarget] = useState<string | null>(null);
|
||||
const [dirRefreshKey, setDirRefreshKey] = useState(0);
|
||||
|
||||
// Refresh rules from PermissionManager
|
||||
const refreshRules = useCallback(() => {
|
||||
if (pm) {
|
||||
setAllRules(pm.listRules());
|
||||
}
|
||||
}, [pm]);
|
||||
|
||||
useEffect(() => {
|
||||
refreshRules();
|
||||
}, [refreshRules]);
|
||||
|
||||
// --- Workspace directory helpers ---
|
||||
const directories = useMemo(() => {
|
||||
// eslint-disable-next-line @typescript-eslint/no-unused-expressions
|
||||
dirRefreshKey; // dependency to trigger re-computation
|
||||
return workspaceContext.getDirectories();
|
||||
}, [workspaceContext, dirRefreshKey]);
|
||||
|
||||
const initialDirs = useMemo(
|
||||
() => new Set(workspaceContext.getInitialDirectories()),
|
||||
[workspaceContext],
|
||||
);
|
||||
|
||||
// Filesystem completions based on current input
|
||||
const dirCompletions = useMemo(() => {
|
||||
const trimmed = newDirInput.trim();
|
||||
if (!trimmed) return [];
|
||||
const expanded = trimmed.startsWith('~')
|
||||
? trimmed.replace(/^~/, os.homedir())
|
||||
: trimmed;
|
||||
const endsWithSep =
|
||||
expanded.endsWith('/') || expanded.endsWith(nodePath.sep);
|
||||
const searchDir = endsWithSep ? expanded : nodePath.dirname(expanded);
|
||||
const prefix = endsWithSep ? '' : nodePath.basename(expanded);
|
||||
try {
|
||||
return fs
|
||||
.readdirSync(searchDir, { withFileTypes: true })
|
||||
.filter(
|
||||
(e) =>
|
||||
e.isDirectory() &&
|
||||
e.name.startsWith(prefix) &&
|
||||
!e.name.startsWith('.'),
|
||||
)
|
||||
.map((e) => nodePath.join(searchDir, e.name))
|
||||
.slice(0, 6);
|
||||
} catch {
|
||||
return [];
|
||||
}
|
||||
}, [newDirInput]);
|
||||
|
||||
const handleDirInputChange = useCallback(
|
||||
(text: string) => {
|
||||
setNewDirInput(text);
|
||||
if (dirInputError) setDirInputError('');
|
||||
},
|
||||
[dirInputError],
|
||||
);
|
||||
|
||||
// Reset selection to first item whenever the completions list changes
|
||||
useEffect(() => {
|
||||
setCompletionIndex(0);
|
||||
}, [dirCompletions]);
|
||||
|
||||
const handleDirTabComplete = useCallback(() => {
|
||||
const selected = dirCompletions[completionIndex] ?? dirCompletions[0];
|
||||
if (selected) {
|
||||
setNewDirInput(selected + '/');
|
||||
setDirInputRemountKey((k) => k + 1);
|
||||
}
|
||||
}, [dirCompletions, completionIndex]);
|
||||
|
||||
const handleDirCompletionUp = useCallback(() => {
|
||||
if (dirCompletions.length === 0) return;
|
||||
setCompletionIndex(
|
||||
(prev) => (prev - 1 + dirCompletions.length) % dirCompletions.length,
|
||||
);
|
||||
}, [dirCompletions.length]);
|
||||
|
||||
const handleDirCompletionDown = useCallback(() => {
|
||||
if (dirCompletions.length === 0) return;
|
||||
setCompletionIndex((prev) => (prev + 1) % dirCompletions.length);
|
||||
}, [dirCompletions.length]);
|
||||
|
||||
const dirListItems = useMemo(() => {
|
||||
const items: Array<{
|
||||
label: string;
|
||||
value: string;
|
||||
key: string;
|
||||
}> = [];
|
||||
// 'Add directory…' always FIRST
|
||||
items.push({
|
||||
label: t('Add directory…'),
|
||||
value: '__add_dir__',
|
||||
key: '__add_dir__',
|
||||
});
|
||||
// Only show non-initial (runtime-added) directories in the selectable list
|
||||
for (const dir of directories) {
|
||||
if (!initialDirs.has(dir)) {
|
||||
items.push({
|
||||
label: dir,
|
||||
value: dir,
|
||||
key: `dir-${dir}`,
|
||||
});
|
||||
}
|
||||
}
|
||||
return items;
|
||||
}, [directories, initialDirs]);
|
||||
|
||||
const handleDirListSelect = useCallback(
|
||||
(value: string) => {
|
||||
if (value === '__add_dir__') {
|
||||
setNewDirInput('');
|
||||
setView('ws-add-dir-input');
|
||||
return;
|
||||
}
|
||||
// Selecting a directory → offer to remove if not initial
|
||||
if (!initialDirs.has(value)) {
|
||||
setRemoveDirTarget(value);
|
||||
setView('ws-remove-confirm');
|
||||
}
|
||||
},
|
||||
[initialDirs],
|
||||
);
|
||||
|
||||
const handleAddDirSubmit = useCallback(() => {
|
||||
const trimmed = newDirInput.trim();
|
||||
if (!trimmed) return;
|
||||
|
||||
const expanded = trimmed.startsWith('~')
|
||||
? trimmed.replace(/^~/, os.homedir())
|
||||
: trimmed;
|
||||
const absoluteExpanded = nodePath.isAbsolute(expanded)
|
||||
? expanded
|
||||
: nodePath.resolve(expanded);
|
||||
|
||||
// Existence & type checks
|
||||
if (!fs.existsSync(absoluteExpanded)) {
|
||||
setDirInputError(t('Directory does not exist.'));
|
||||
return;
|
||||
}
|
||||
if (!fs.statSync(absoluteExpanded).isDirectory()) {
|
||||
setDirInputError(t('Path is not a directory.'));
|
||||
return;
|
||||
}
|
||||
|
||||
// Resolve real path to match what workspaceContext stores
|
||||
let resolved: string;
|
||||
try {
|
||||
resolved = fs.realpathSync(absoluteExpanded);
|
||||
} catch {
|
||||
resolved = absoluteExpanded;
|
||||
}
|
||||
|
||||
// Validate: exact duplicate
|
||||
if ((directories as string[]).includes(resolved)) {
|
||||
setDirInputError(t('This directory is already in the workspace.'));
|
||||
return;
|
||||
}
|
||||
|
||||
// Validate: is a subdirectory of an existing workspace directory
|
||||
for (const existingDir of directories) {
|
||||
if (isPathWithinRoot(resolved, existingDir)) {
|
||||
setDirInputError(
|
||||
t('Already covered by existing directory: {{dir}}', {
|
||||
dir: existingDir,
|
||||
}),
|
||||
);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
setDirInputError('');
|
||||
|
||||
// Add to workspace context (already validated)
|
||||
workspaceContext.addDirectory(resolved);
|
||||
|
||||
// Persist directly to project (Workspace) settings
|
||||
const key = 'context.includeDirectories';
|
||||
const currentDirs = (settings.merged as Record<string, unknown>)[
|
||||
'context'
|
||||
] as Record<string, string[]> | undefined;
|
||||
const existingDirs = currentDirs?.['includeDirectories'] ?? [];
|
||||
if (!existingDirs.includes(resolved)) {
|
||||
settings.setValue(SettingScope.Workspace, key, [
|
||||
...existingDirs,
|
||||
resolved,
|
||||
]);
|
||||
}
|
||||
|
||||
setDirRefreshKey((k) => k + 1);
|
||||
setView('ws-dir-list');
|
||||
setNewDirInput('');
|
||||
}, [newDirInput, directories, workspaceContext, settings]);
|
||||
|
||||
const handleRemoveDirConfirm = useCallback(() => {
|
||||
if (!removeDirTarget) return;
|
||||
|
||||
// Remove from workspace context
|
||||
workspaceContext.removeDirectory(removeDirTarget);
|
||||
|
||||
// Remove from settings (try both scopes)
|
||||
for (const scope of [SettingScope.User, SettingScope.Workspace]) {
|
||||
const scopeSettings = settings.forScope(scope).settings;
|
||||
const contextSection = (scopeSettings as Record<string, unknown>)[
|
||||
'context'
|
||||
] as Record<string, string[]> | undefined;
|
||||
const scopeDirs = contextSection?.['includeDirectories'];
|
||||
if (scopeDirs?.includes(removeDirTarget)) {
|
||||
const updated = scopeDirs.filter((d: string) => d !== removeDirTarget);
|
||||
settings.setValue(scope, 'context.includeDirectories', updated);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
setDirRefreshKey((k) => k + 1);
|
||||
setRemoveDirTarget(null);
|
||||
setView('ws-dir-list');
|
||||
}, [removeDirTarget, workspaceContext, settings]);
|
||||
|
||||
// Filter rules for current tab
|
||||
const currentTabRules = useMemo(() => {
|
||||
if (activeTab.id === 'workspace') return [];
|
||||
return allRules.filter((r) => r.type === activeTab.id);
|
||||
}, [allRules, activeTab.id]);
|
||||
|
||||
// Search-filtered rules
|
||||
const filteredRules = useMemo(() => {
|
||||
if (!searchQuery.trim()) return currentTabRules;
|
||||
const q = searchQuery.toLowerCase();
|
||||
return currentTabRules.filter(
|
||||
(r) =>
|
||||
r.rule.raw.toLowerCase().includes(q) ||
|
||||
r.rule.toolName.toLowerCase().includes(q),
|
||||
);
|
||||
}, [currentTabRules, searchQuery]);
|
||||
|
||||
// Build radio items: "Add a new rule..." + filtered rules
|
||||
const listItems = useMemo(() => {
|
||||
const items: Array<{
|
||||
label: string;
|
||||
value: string;
|
||||
key: string;
|
||||
}> = [
|
||||
{
|
||||
label: t('Add a new rule…'),
|
||||
value: '__add__',
|
||||
key: '__add__',
|
||||
},
|
||||
];
|
||||
for (const r of filteredRules) {
|
||||
items.push({
|
||||
label: `${r.rule.raw}`,
|
||||
value: r.rule.raw,
|
||||
key: `${r.type}-${r.scope}-${r.rule.raw}`,
|
||||
});
|
||||
}
|
||||
return items;
|
||||
}, [filteredRules]);
|
||||
|
||||
// --- Action handlers ---
|
||||
|
||||
const handleTabCycle = useCallback(
|
||||
(direction: 1 | -1) => {
|
||||
const newIndex = (activeTabIndex + direction + tabs.length) % tabs.length;
|
||||
setActiveTabIndex(newIndex);
|
||||
setSearchQuery('');
|
||||
setIsSearchActive(false);
|
||||
setDirInputError('');
|
||||
// Set the appropriate default view for each tab
|
||||
const newTab = tabs[newIndex]!;
|
||||
setView(newTab.id === 'workspace' ? 'ws-dir-list' : 'rule-list');
|
||||
},
|
||||
[activeTabIndex, tabs],
|
||||
);
|
||||
|
||||
const handleListSelect = useCallback(
|
||||
(value: string) => {
|
||||
if (value === '__add__') {
|
||||
setNewRuleInput('');
|
||||
setView('add-rule-input');
|
||||
return;
|
||||
}
|
||||
// Selecting an existing rule → offer to delete
|
||||
const found = filteredRules.find((r) => r.rule.raw === value);
|
||||
if (found) {
|
||||
setDeleteTarget(found);
|
||||
setView('delete-confirm');
|
||||
}
|
||||
},
|
||||
[filteredRules],
|
||||
);
|
||||
|
||||
const handleAddRuleSubmit = useCallback(() => {
|
||||
const trimmed = newRuleInput.trim();
|
||||
if (!trimmed) return;
|
||||
setPendingRuleText(trimmed);
|
||||
setView('add-rule-scope');
|
||||
}, [newRuleInput]);
|
||||
|
||||
const handleScopeSelect = useCallback(
|
||||
(scope: SettingScope) => {
|
||||
if (!pm || activeTab.id === 'workspace') return;
|
||||
const ruleType = activeTab.id as RuleType;
|
||||
|
||||
// Add to PermissionManager in-memory
|
||||
pm.addPersistentRule(pendingRuleText, ruleType);
|
||||
|
||||
// Persist to settings file (with dedup)
|
||||
const key = `permissions.${ruleType}`;
|
||||
const perms = (settings.merged as Record<string, unknown>)[
|
||||
'permissions'
|
||||
] as Record<string, string[]> | undefined;
|
||||
const currentRules = perms?.[ruleType] ?? [];
|
||||
if (!currentRules.includes(pendingRuleText)) {
|
||||
settings.setValue(scope, key, [...currentRules, pendingRuleText]);
|
||||
}
|
||||
|
||||
// Refresh and go back
|
||||
refreshRules();
|
||||
setView('rule-list');
|
||||
setPendingRuleText('');
|
||||
},
|
||||
[pm, activeTab.id, pendingRuleText, settings, refreshRules],
|
||||
);
|
||||
|
||||
const handleDeleteConfirm = useCallback(() => {
|
||||
if (!pm || !deleteTarget) return;
|
||||
const ruleType = deleteTarget.type;
|
||||
|
||||
// Remove from PermissionManager in-memory
|
||||
pm.removePersistentRule(deleteTarget.rule.raw, ruleType);
|
||||
|
||||
// Persist removal — find and remove from settings
|
||||
// We try both User and Workspace scopes
|
||||
for (const scope of [SettingScope.User, SettingScope.Workspace]) {
|
||||
const scopeSettings = settings.forScope(scope).settings;
|
||||
const perms = (scopeSettings as Record<string, unknown>)[
|
||||
'permissions'
|
||||
] as Record<string, string[]> | undefined;
|
||||
const scopeRules = perms?.[ruleType];
|
||||
if (scopeRules?.includes(deleteTarget.rule.raw)) {
|
||||
const updated = scopeRules.filter(
|
||||
(r: string) => r !== deleteTarget.rule.raw,
|
||||
);
|
||||
settings.setValue(scope, `permissions.${ruleType}`, updated);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
refreshRules();
|
||||
setDeleteTarget(null);
|
||||
setView('rule-list');
|
||||
}, [pm, deleteTarget, settings, refreshRules]);
|
||||
|
||||
// --- Keypress handling ---
|
||||
|
||||
useKeypress(
|
||||
(key) => {
|
||||
if (view === 'rule-list') {
|
||||
if (key.name === 'escape') {
|
||||
if (isSearchActive && searchQuery) {
|
||||
setSearchQuery('');
|
||||
setIsSearchActive(false);
|
||||
} else {
|
||||
onExit();
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (key.name === 'tab') {
|
||||
handleTabCycle(1);
|
||||
return;
|
||||
}
|
||||
if (key.name === 'right' || key.name === 'left') {
|
||||
handleTabCycle(key.name === 'right' ? 1 : -1);
|
||||
return;
|
||||
}
|
||||
// Search input: backspace
|
||||
if (key.name === 'backspace' || key.name === 'delete') {
|
||||
if (searchQuery.length > 0) {
|
||||
setSearchQuery((prev) => prev.slice(0, -1));
|
||||
}
|
||||
return;
|
||||
}
|
||||
// Search input: printable characters
|
||||
if (
|
||||
key.sequence &&
|
||||
!key.ctrl &&
|
||||
!key.meta &&
|
||||
key.sequence.length === 1 &&
|
||||
key.sequence >= ' '
|
||||
) {
|
||||
setSearchQuery((prev) => prev + key.sequence);
|
||||
setIsSearchActive(true);
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (view === 'add-rule-input') {
|
||||
if (key.name === 'escape') {
|
||||
setView('rule-list');
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (view === 'add-rule-scope') {
|
||||
if (key.name === 'escape') {
|
||||
setView('add-rule-input');
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (view === 'delete-confirm') {
|
||||
if (key.name === 'escape') {
|
||||
setDeleteTarget(null);
|
||||
setView('rule-list');
|
||||
return;
|
||||
}
|
||||
if (key.name === 'return') {
|
||||
handleDeleteConfirm();
|
||||
return;
|
||||
}
|
||||
}
|
||||
// Workspace tab views
|
||||
if (view === 'ws-dir-list') {
|
||||
if (key.name === 'escape') {
|
||||
onExit();
|
||||
return;
|
||||
}
|
||||
if (key.name === 'tab') {
|
||||
handleTabCycle(1);
|
||||
return;
|
||||
}
|
||||
if (key.name === 'right' || key.name === 'left') {
|
||||
handleTabCycle(key.name === 'right' ? 1 : -1);
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (view === 'ws-add-dir-input') {
|
||||
if (key.name === 'escape') {
|
||||
setDirInputError('');
|
||||
setView('ws-dir-list');
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (view === 'ws-remove-confirm') {
|
||||
if (key.name === 'escape') {
|
||||
setRemoveDirTarget(null);
|
||||
setView('ws-dir-list');
|
||||
return;
|
||||
}
|
||||
if (key.name === 'return') {
|
||||
handleRemoveDirConfirm();
|
||||
return;
|
||||
}
|
||||
}
|
||||
},
|
||||
{ isActive: true },
|
||||
);
|
||||
|
||||
// --- Workspace tab: add directory input ---
|
||||
if (activeTab.id === 'workspace' && view === 'ws-add-dir-input') {
|
||||
return (
|
||||
<Box flexDirection="column">
|
||||
<Text bold color={theme.text.accent}>
|
||||
{t('Add directory to workspace')}
|
||||
</Text>
|
||||
<Box height={1} />
|
||||
<Text color={theme.text.secondary} wrap="wrap">
|
||||
{t(
|
||||
'Qwen Code will be able to read files in this directory and make edits when auto-accept edits is on.',
|
||||
)}
|
||||
</Text>
|
||||
<Box height={1} />
|
||||
<Text>{t('Enter the path to the directory:')}</Text>
|
||||
<Box
|
||||
borderStyle="round"
|
||||
borderColor={theme.border.default}
|
||||
paddingLeft={1}
|
||||
paddingRight={1}
|
||||
marginTop={1}
|
||||
>
|
||||
<TextInput
|
||||
key={dirInputRemountKey}
|
||||
value={newDirInput}
|
||||
onChange={handleDirInputChange}
|
||||
onSubmit={handleAddDirSubmit}
|
||||
onTab={dirCompletions.length > 0 ? handleDirTabComplete : undefined}
|
||||
onUp={dirCompletions.length > 0 ? handleDirCompletionUp : undefined}
|
||||
onDown={
|
||||
dirCompletions.length > 0 ? handleDirCompletionDown : undefined
|
||||
}
|
||||
placeholder={t('Enter directory path…')}
|
||||
isActive={true}
|
||||
validationErrors={dirInputError ? [dirInputError] : []}
|
||||
/>
|
||||
</Box>
|
||||
{/* Filesystem completions: ↑/↓ to navigate, Tab to apply */}
|
||||
{dirCompletions.length > 0 && (
|
||||
<Box flexDirection="column" marginTop={1} paddingLeft={2}>
|
||||
{dirCompletions.map((completion, idx) => {
|
||||
const name = nodePath.basename(completion);
|
||||
const isSelected = idx === completionIndex;
|
||||
return (
|
||||
<Box key={completion}>
|
||||
<Text
|
||||
bold={isSelected}
|
||||
color={
|
||||
isSelected ? theme.text.primary : theme.text.secondary
|
||||
}
|
||||
>
|
||||
{`${name}/`}
|
||||
</Text>
|
||||
<Text color={theme.text.secondary}>{` directory`}</Text>
|
||||
</Box>
|
||||
);
|
||||
})}
|
||||
</Box>
|
||||
)}
|
||||
<Box marginTop={1}>
|
||||
<Text color={theme.text.secondary}>
|
||||
{t('Tab to complete · Enter to add · Esc to cancel')}
|
||||
</Text>
|
||||
</Box>
|
||||
</Box>
|
||||
);
|
||||
}
|
||||
|
||||
// --- Workspace tab: remove directory confirmation ---
|
||||
if (
|
||||
activeTab.id === 'workspace' &&
|
||||
view === 'ws-remove-confirm' &&
|
||||
removeDirTarget
|
||||
) {
|
||||
return (
|
||||
<Box flexDirection="column">
|
||||
<Box
|
||||
borderStyle="round"
|
||||
borderColor={theme.border.default}
|
||||
flexDirection="column"
|
||||
padding={1}
|
||||
>
|
||||
<Text bold>{t('Remove directory?')}</Text>
|
||||
<Box height={1} />
|
||||
<Box marginLeft={2} flexDirection="column">
|
||||
<Text bold>{removeDirTarget}</Text>
|
||||
</Box>
|
||||
<Box height={1} />
|
||||
<Text>
|
||||
{t(
|
||||
'Are you sure you want to remove this directory from the workspace?',
|
||||
)}
|
||||
</Text>
|
||||
</Box>
|
||||
<Box marginTop={1} marginLeft={1}>
|
||||
<Text color={theme.text.secondary}>
|
||||
{t('Enter to confirm · Esc to cancel')}
|
||||
</Text>
|
||||
</Box>
|
||||
</Box>
|
||||
);
|
||||
}
|
||||
|
||||
// --- Workspace tab: directory list (default) ---
|
||||
if (activeTab.id === 'workspace') {
|
||||
const initialDirArray = Array.from(initialDirs);
|
||||
return (
|
||||
<Box flexDirection="column">
|
||||
<TabBar tabs={tabs} activeIndex={activeTabIndex} />
|
||||
<Text color={theme.text.secondary} wrap="wrap">
|
||||
{t(
|
||||
'Qwen Code can read files in the workspace, and make edits when auto-accept edits is on.',
|
||||
)}
|
||||
</Text>
|
||||
<Box height={1} />
|
||||
{/* Initial (non-removable) dirs: shown inline with dash, same visual level as list */}
|
||||
{initialDirArray.map((dir, idx) => (
|
||||
<Box key={dir} marginLeft={2}>
|
||||
<Text color={theme.text.secondary}>{'- '}</Text>
|
||||
<Text>{dir}</Text>
|
||||
<Text color={theme.text.secondary}>
|
||||
{idx === 0
|
||||
? t(' (Original working directory)')
|
||||
: t(' (from settings)')}
|
||||
</Text>
|
||||
</Box>
|
||||
))}
|
||||
{/* Selectable list: runtime-added dirs + 'Add directory…' at end */}
|
||||
<RadioButtonSelect
|
||||
items={dirListItems}
|
||||
onSelect={handleDirListSelect}
|
||||
isFocused={view === 'ws-dir-list'}
|
||||
showNumbers={true}
|
||||
showScrollArrows={false}
|
||||
maxItemsToShow={15}
|
||||
/>
|
||||
<FooterHint view={view} />
|
||||
</Box>
|
||||
);
|
||||
}
|
||||
|
||||
// --- Render views ---
|
||||
|
||||
if (view === 'add-rule-input') {
|
||||
return (
|
||||
<Box flexDirection="column">
|
||||
<Box
|
||||
borderStyle="round"
|
||||
borderColor={theme.border.default}
|
||||
flexDirection="column"
|
||||
padding={1}
|
||||
>
|
||||
<Text bold>
|
||||
{t('Add {{type}} permission rule', { type: activeTab.id })}
|
||||
</Text>
|
||||
<Box height={1} />
|
||||
<Text wrap="wrap">
|
||||
{t(
|
||||
'Permission rules are a tool name, optionally followed by a specifier in parentheses.',
|
||||
)}
|
||||
</Text>
|
||||
<Text>
|
||||
{t('e.g.,')} <Text bold>WebFetch</Text> {t('or')}{' '}
|
||||
<Text bold>Bash(ls:*)</Text>
|
||||
</Text>
|
||||
<Box height={1} />
|
||||
<Box
|
||||
borderStyle="round"
|
||||
borderColor={theme.border.default}
|
||||
paddingLeft={1}
|
||||
paddingRight={1}
|
||||
>
|
||||
<TextInput
|
||||
value={newRuleInput}
|
||||
onChange={setNewRuleInput}
|
||||
onSubmit={handleAddRuleSubmit}
|
||||
placeholder={t('Enter permission rule…')}
|
||||
isActive={true}
|
||||
/>
|
||||
</Box>
|
||||
</Box>
|
||||
<Box marginTop={1} marginLeft={1}>
|
||||
<Text color={theme.text.secondary}>
|
||||
{t('Enter to submit · Esc to cancel')}
|
||||
</Text>
|
||||
</Box>
|
||||
</Box>
|
||||
);
|
||||
}
|
||||
|
||||
if (view === 'add-rule-scope') {
|
||||
const scopeItems = getPermScopeItems();
|
||||
return (
|
||||
<Box flexDirection="column">
|
||||
<Box
|
||||
borderStyle="round"
|
||||
borderColor={theme.border.default}
|
||||
flexDirection="column"
|
||||
padding={1}
|
||||
>
|
||||
<Text bold>
|
||||
{t('Add {{type}} permission rule', { type: activeTab.id })}
|
||||
</Text>
|
||||
<Box height={1} />
|
||||
<Box marginLeft={2} flexDirection="column">
|
||||
<Text bold>{pendingRuleText}</Text>
|
||||
<Text color={theme.text.secondary}>
|
||||
{describeRule(pendingRuleText)}
|
||||
</Text>
|
||||
</Box>
|
||||
<Box height={1} />
|
||||
<Text>{t('Where should this rule be saved?')}</Text>
|
||||
<RadioButtonSelect
|
||||
items={scopeItems.map((s) => ({
|
||||
label: `${s.label} ${s.description}`,
|
||||
value: s.value,
|
||||
key: s.key,
|
||||
}))}
|
||||
onSelect={handleScopeSelect}
|
||||
isFocused={true}
|
||||
showNumbers={true}
|
||||
/>
|
||||
</Box>
|
||||
<Box marginTop={1} marginLeft={1}>
|
||||
<Text color={theme.text.secondary}>
|
||||
{t('Enter to confirm · Esc to cancel')}
|
||||
</Text>
|
||||
</Box>
|
||||
</Box>
|
||||
);
|
||||
}
|
||||
|
||||
if (view === 'delete-confirm' && deleteTarget) {
|
||||
return (
|
||||
<Box flexDirection="column">
|
||||
<Box
|
||||
borderStyle="round"
|
||||
borderColor={theme.border.default}
|
||||
flexDirection="column"
|
||||
padding={1}
|
||||
>
|
||||
<Text bold>
|
||||
{t('Delete {{type}} rule?', { type: deleteTarget.type })}
|
||||
</Text>
|
||||
<Box height={1} />
|
||||
<Box marginLeft={2} flexDirection="column">
|
||||
<Text bold>{deleteTarget.rule.raw}</Text>
|
||||
<Text color={theme.text.secondary}>
|
||||
{describeRule(deleteTarget.rule.raw)}
|
||||
</Text>
|
||||
<Text color={theme.text.secondary}>
|
||||
{scopeLabel(deleteTarget.scope)}
|
||||
</Text>
|
||||
</Box>
|
||||
<Box height={1} />
|
||||
<Text>
|
||||
{t('Are you sure you want to delete this permission rule?')}
|
||||
</Text>
|
||||
</Box>
|
||||
<Box marginTop={1} marginLeft={1}>
|
||||
<Text color={theme.text.secondary}>
|
||||
{t('Enter to confirm · Esc to cancel')}
|
||||
</Text>
|
||||
</Box>
|
||||
</Box>
|
||||
);
|
||||
}
|
||||
|
||||
// --- Default: rule-list view ---
|
||||
|
||||
return (
|
||||
<Box flexDirection="column">
|
||||
<TabBar tabs={tabs} activeIndex={activeTabIndex} />
|
||||
<Text>{activeTab.description}</Text>
|
||||
{/* Search box */}
|
||||
<Box
|
||||
borderStyle="round"
|
||||
borderColor={theme.border.default}
|
||||
paddingLeft={1}
|
||||
paddingRight={1}
|
||||
width={60}
|
||||
>
|
||||
<Text color={theme.text.accent}>{'> '}</Text>
|
||||
{searchQuery ? (
|
||||
<Text>{searchQuery}</Text>
|
||||
) : (
|
||||
<Text color={Colors.Gray}>{t('Search…')}</Text>
|
||||
)}
|
||||
</Box>
|
||||
<Box height={1} />
|
||||
{/* Rule list */}
|
||||
<RadioButtonSelect
|
||||
items={listItems}
|
||||
onSelect={handleListSelect}
|
||||
isFocused={view === 'rule-list'}
|
||||
showNumbers={true}
|
||||
showScrollArrows={false}
|
||||
maxItemsToShow={15}
|
||||
/>
|
||||
<FooterHint view={view} />
|
||||
</Box>
|
||||
);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Sub-components
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function TabBar({
|
||||
tabs,
|
||||
activeIndex,
|
||||
}: {
|
||||
tabs: Tab[];
|
||||
activeIndex: number;
|
||||
}): React.JSX.Element {
|
||||
return (
|
||||
<Box marginBottom={1}>
|
||||
<Text color={theme.text.accent} bold>
|
||||
{t('Permissions:')}{' '}
|
||||
</Text>
|
||||
{tabs.map((tab, i) => (
|
||||
<Box key={tab.id} marginRight={2}>
|
||||
{i === activeIndex ? (
|
||||
<Text
|
||||
bold
|
||||
backgroundColor={theme.text.accent}
|
||||
color={theme.background.primary}
|
||||
>
|
||||
{` ${tab.label} `}
|
||||
</Text>
|
||||
) : (
|
||||
<Text color={theme.text.secondary}>{` ${tab.label} `}</Text>
|
||||
)}
|
||||
</Box>
|
||||
))}
|
||||
<Text color={theme.text.secondary}>{t('(←/→ or tab to cycle)')}</Text>
|
||||
</Box>
|
||||
);
|
||||
}
|
||||
|
||||
function FooterHint({ view }: { view: DialogView }): React.JSX.Element {
|
||||
if (view !== 'rule-list' && view !== 'ws-dir-list') return <></>;
|
||||
return (
|
||||
<Box marginTop={1}>
|
||||
<Text color={theme.text.secondary}>
|
||||
{t(
|
||||
'Press ↑↓ to navigate · Enter to select · Type to search · Esc to cancel',
|
||||
)}
|
||||
</Text>
|
||||
</Box>
|
||||
);
|
||||
}
|
||||
|
|
@ -33,13 +33,13 @@ describe('ShellConfirmationDialog', () => {
|
|||
expect(select).toContain('Yes, allow once');
|
||||
});
|
||||
|
||||
it('calls onConfirm with ProceedAlways when "Yes, allow always for this session" is selected', () => {
|
||||
it('calls onConfirm with ProceedAlwaysProject when "Always allow in this project" is selected', () => {
|
||||
const { lastFrame } = renderWithProviders(
|
||||
<ShellConfirmationDialog request={request} />,
|
||||
);
|
||||
const select = lastFrame()!.toString();
|
||||
// Simulate selecting the second option
|
||||
expect(select).toContain('Yes, allow always for this session');
|
||||
expect(select).toContain('Always allow in this project');
|
||||
});
|
||||
|
||||
it('calls onConfirm with Cancel when "No (esc)" is selected', () => {
|
||||
|
|
|
|||
|
|
@ -57,9 +57,14 @@ export const ShellConfirmationDialog: React.FC<
|
|||
key: 'Yes, allow once',
|
||||
},
|
||||
{
|
||||
label: t('Yes, allow always for this session'),
|
||||
value: ToolConfirmationOutcome.ProceedAlways,
|
||||
key: 'Yes, allow always for this session',
|
||||
label: t('Always allow in this project'),
|
||||
value: ToolConfirmationOutcome.ProceedAlwaysProject,
|
||||
key: 'Always allow in this project',
|
||||
},
|
||||
{
|
||||
label: t('Always allow for this user'),
|
||||
value: ToolConfirmationOutcome.ProceedAlwaysUser,
|
||||
key: 'Always allow for this user',
|
||||
},
|
||||
{
|
||||
label: t('No (esc)'),
|
||||
|
|
|
|||
|
|
@ -9,13 +9,13 @@
|
|||
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
|
||||
import type { Mock } from 'vitest';
|
||||
import { renderWithProviders } from '../../test-utils/render.js';
|
||||
import { PermissionsModifyTrustDialog } from './PermissionsModifyTrustDialog.js';
|
||||
import { TrustDialog } from './TrustDialog.js';
|
||||
import { TrustLevel } from '../../config/trustedFolders.js';
|
||||
import { waitFor, act } from '@testing-library/react';
|
||||
import * as processUtils from '../../utils/processUtils.js';
|
||||
import { usePermissionsModifyTrust } from '../hooks/usePermissionsModifyTrust.js';
|
||||
import { useTrustModify } from '../hooks/useTrustModify.js';
|
||||
|
||||
// Hoist mocks for dependencies of the usePermissionsModifyTrust hook
|
||||
// Hoist mocks for dependencies of the useTrustModify hook
|
||||
const mockedCwd = vi.hoisted(() => vi.fn());
|
||||
const mockedLoadTrustedFolders = vi.hoisted(() => vi.fn());
|
||||
const mockedIsWorkspaceTrusted = vi.hoisted(() => vi.fn());
|
||||
|
|
@ -39,16 +39,16 @@ vi.mock('../../config/trustedFolders.js', () => ({
|
|||
},
|
||||
}));
|
||||
|
||||
vi.mock('../hooks/usePermissionsModifyTrust.js');
|
||||
vi.mock('../hooks/useTrustModify.js');
|
||||
|
||||
describe('PermissionsModifyTrustDialog', () => {
|
||||
describe('TrustDialog', () => {
|
||||
let mockUpdateTrustLevel: Mock;
|
||||
let mockCommitTrustLevelChange: Mock;
|
||||
|
||||
beforeEach(() => {
|
||||
mockUpdateTrustLevel = vi.fn();
|
||||
mockCommitTrustLevelChange = vi.fn();
|
||||
vi.mocked(usePermissionsModifyTrust).mockReturnValue({
|
||||
vi.mocked(useTrustModify).mockReturnValue({
|
||||
cwd: '/test/dir',
|
||||
currentTrustLevel: TrustLevel.DO_NOT_TRUST,
|
||||
isInheritedTrustFromParent: false,
|
||||
|
|
@ -66,7 +66,7 @@ describe('PermissionsModifyTrustDialog', () => {
|
|||
|
||||
it('should render the main dialog with current trust level', async () => {
|
||||
const { lastFrame } = renderWithProviders(
|
||||
<PermissionsModifyTrustDialog onExit={vi.fn()} addItem={vi.fn()} />,
|
||||
<TrustDialog onExit={vi.fn()} addItem={vi.fn()} />,
|
||||
);
|
||||
|
||||
await waitFor(() => {
|
||||
|
|
@ -77,7 +77,7 @@ describe('PermissionsModifyTrustDialog', () => {
|
|||
});
|
||||
|
||||
it('should display the inherited trust note from parent', async () => {
|
||||
vi.mocked(usePermissionsModifyTrust).mockReturnValue({
|
||||
vi.mocked(useTrustModify).mockReturnValue({
|
||||
cwd: '/test/dir',
|
||||
currentTrustLevel: TrustLevel.DO_NOT_TRUST,
|
||||
isInheritedTrustFromParent: true,
|
||||
|
|
@ -88,7 +88,7 @@ describe('PermissionsModifyTrustDialog', () => {
|
|||
isFolderTrustEnabled: true,
|
||||
});
|
||||
const { lastFrame } = renderWithProviders(
|
||||
<PermissionsModifyTrustDialog onExit={vi.fn()} addItem={vi.fn()} />,
|
||||
<TrustDialog onExit={vi.fn()} addItem={vi.fn()} />,
|
||||
);
|
||||
|
||||
await waitFor(() => {
|
||||
|
|
@ -99,7 +99,7 @@ describe('PermissionsModifyTrustDialog', () => {
|
|||
});
|
||||
|
||||
it('should display the inherited trust note from IDE', async () => {
|
||||
vi.mocked(usePermissionsModifyTrust).mockReturnValue({
|
||||
vi.mocked(useTrustModify).mockReturnValue({
|
||||
cwd: '/test/dir',
|
||||
currentTrustLevel: TrustLevel.DO_NOT_TRUST,
|
||||
isInheritedTrustFromParent: false,
|
||||
|
|
@ -110,7 +110,7 @@ describe('PermissionsModifyTrustDialog', () => {
|
|||
isFolderTrustEnabled: true,
|
||||
});
|
||||
const { lastFrame } = renderWithProviders(
|
||||
<PermissionsModifyTrustDialog onExit={vi.fn()} addItem={vi.fn()} />,
|
||||
<TrustDialog onExit={vi.fn()} addItem={vi.fn()} />,
|
||||
);
|
||||
|
||||
await waitFor(() => {
|
||||
|
|
@ -123,7 +123,7 @@ describe('PermissionsModifyTrustDialog', () => {
|
|||
it('should call onExit when escape is pressed', async () => {
|
||||
const onExit = vi.fn();
|
||||
const { stdin, lastFrame } = renderWithProviders(
|
||||
<PermissionsModifyTrustDialog onExit={onExit} addItem={vi.fn()} />,
|
||||
<TrustDialog onExit={onExit} addItem={vi.fn()} />,
|
||||
);
|
||||
|
||||
await waitFor(() => expect(lastFrame()).not.toContain('Loading...'));
|
||||
|
|
@ -141,7 +141,7 @@ describe('PermissionsModifyTrustDialog', () => {
|
|||
const mockRelaunchApp = vi
|
||||
.spyOn(processUtils, 'relaunchApp')
|
||||
.mockResolvedValue(undefined);
|
||||
vi.mocked(usePermissionsModifyTrust).mockReturnValue({
|
||||
vi.mocked(useTrustModify).mockReturnValue({
|
||||
cwd: '/test/dir',
|
||||
currentTrustLevel: TrustLevel.DO_NOT_TRUST,
|
||||
isInheritedTrustFromParent: false,
|
||||
|
|
@ -154,7 +154,7 @@ describe('PermissionsModifyTrustDialog', () => {
|
|||
|
||||
const onExit = vi.fn();
|
||||
const { stdin, lastFrame } = renderWithProviders(
|
||||
<PermissionsModifyTrustDialog onExit={onExit} addItem={vi.fn()} />,
|
||||
<TrustDialog onExit={onExit} addItem={vi.fn()} />,
|
||||
);
|
||||
|
||||
await waitFor(() => expect(lastFrame()).not.toContain('Loading...'));
|
||||
|
|
@ -171,7 +171,7 @@ describe('PermissionsModifyTrustDialog', () => {
|
|||
});
|
||||
|
||||
it('should not commit when escape is pressed during restart prompt', async () => {
|
||||
vi.mocked(usePermissionsModifyTrust).mockReturnValue({
|
||||
vi.mocked(useTrustModify).mockReturnValue({
|
||||
cwd: '/test/dir',
|
||||
currentTrustLevel: TrustLevel.DO_NOT_TRUST,
|
||||
isInheritedTrustFromParent: false,
|
||||
|
|
@ -184,7 +184,7 @@ describe('PermissionsModifyTrustDialog', () => {
|
|||
|
||||
const onExit = vi.fn();
|
||||
const { stdin, lastFrame } = renderWithProviders(
|
||||
<PermissionsModifyTrustDialog onExit={onExit} addItem={vi.fn()} />,
|
||||
<TrustDialog onExit={onExit} addItem={vi.fn()} />,
|
||||
);
|
||||
|
||||
await waitFor(() => expect(lastFrame()).not.toContain('Loading...'));
|
||||
|
|
@ -8,13 +8,13 @@ import { Box, Text } from 'ink';
|
|||
import type React from 'react';
|
||||
import { TrustLevel } from '../../config/trustedFolders.js';
|
||||
import { useKeypress } from '../hooks/useKeypress.js';
|
||||
import { usePermissionsModifyTrust } from '../hooks/usePermissionsModifyTrust.js';
|
||||
import { useTrustModify } from '../hooks/useTrustModify.js';
|
||||
import { theme } from '../semantic-colors.js';
|
||||
import { RadioButtonSelect } from './shared/RadioButtonSelect.js';
|
||||
import { relaunchApp } from '../../utils/processUtils.js';
|
||||
import { type UseHistoryManagerReturn } from '../hooks/useHistoryManager.js';
|
||||
|
||||
interface PermissionsModifyTrustDialogProps {
|
||||
interface TrustDialogProps {
|
||||
onExit: () => void;
|
||||
addItem: UseHistoryManagerReturn['addItem'];
|
||||
}
|
||||
|
|
@ -37,10 +37,10 @@ const TRUST_LEVEL_ITEMS = [
|
|||
},
|
||||
];
|
||||
|
||||
export function PermissionsModifyTrustDialog({
|
||||
export function TrustDialog({
|
||||
onExit,
|
||||
addItem,
|
||||
}: PermissionsModifyTrustDialogProps): React.JSX.Element {
|
||||
}: TrustDialogProps): React.JSX.Element {
|
||||
const {
|
||||
cwd,
|
||||
currentTrustLevel,
|
||||
|
|
@ -49,7 +49,7 @@ export function PermissionsModifyTrustDialog({
|
|||
needsRestart,
|
||||
updateTrustLevel,
|
||||
commitTrustLevelChange,
|
||||
} = usePermissionsModifyTrust(onExit, addItem);
|
||||
} = useTrustModify(onExit, addItem);
|
||||
|
||||
useKeypress(
|
||||
(key) => {
|
||||
|
|
@ -7,7 +7,7 @@ exports[`LoopDetectionConfirmation > renders correctly 1`] = `
|
|||
│ This can happen due to repetitive tool calls or other model behavior. Do you want to keep loop │
|
||||
│ detection enabled or disable it for this session? │
|
||||
│ │
|
||||
│ ● 1. Keep loop detection enabled (esc) │
|
||||
│ › 1. Keep loop detection enabled (esc) │
|
||||
│ 2. Disable loop detection for this session │
|
||||
│ │
|
||||
│ Note: To disable loop detection checks for all future sessions, set "model.skipLoopDetection" to │
|
||||
|
|
|
|||
|
|
@ -13,9 +13,10 @@ exports[`ShellConfirmationDialog > renders correctly 1`] = `
|
|||
│ │
|
||||
│ Do you want to proceed? │
|
||||
│ │
|
||||
│ ● 1. Yes, allow once │
|
||||
│ 2. Yes, allow always for this session │
|
||||
│ 3. No (esc) │
|
||||
│ › 1. Yes, allow once │
|
||||
│ 2. Always allow in this project │
|
||||
│ 3. Always allow for this user │
|
||||
│ 4. No (esc) │
|
||||
│ │
|
||||
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯"
|
||||
`;
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ exports[`ThemeDialog Snapshots > should render correctly in scope selector mode
|
|||
│ │
|
||||
│ > Apply To │
|
||||
│ │
|
||||
│ ● 1. User Settings │
|
||||
│ › 1. User Settings │
|
||||
│ 2. Workspace Settings │
|
||||
│ │
|
||||
│ (Use Enter to apply scope, Tab to go back) │
|
||||
|
|
@ -19,7 +19,7 @@ exports[`ThemeDialog Snapshots > should render correctly in theme selection mode
|
|||
│ > Select Theme Preview │
|
||||
│ ▲ ┌─────────────────────────────────────────────────┐ │
|
||||
│ 1. Qwen Light Light │ │ │
|
||||
│ ● 2. Qwen Dark Dark │ 1 # function │ │
|
||||
│ › 2. Qwen Dark Dark │ 1 # function │ │
|
||||
│ 3. ANSI Dark │ 2 def fibonacci(n): │ │
|
||||
│ 4. Atom One Dark │ 3 a, b = 0, 1 │ │
|
||||
│ 5. Ayu Dark │ 4 for _ in range(n): │ │
|
||||
|
|
|
|||
|
|
@ -1,33 +1,33 @@
|
|||
// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
|
||||
|
||||
exports[`ActionSelectionStep Snapshots > should render for active extension without update 1`] = `
|
||||
"● View Details
|
||||
"› View Details
|
||||
Disable Extension
|
||||
Uninstall Extension"
|
||||
`;
|
||||
|
||||
exports[`ActionSelectionStep Snapshots > should render for disabled extension 1`] = `
|
||||
"● View Details
|
||||
"› View Details
|
||||
Enable Extension
|
||||
Uninstall Extension"
|
||||
`;
|
||||
|
||||
exports[`ActionSelectionStep Snapshots > should render for disabled extension with update 1`] = `
|
||||
"● View Details
|
||||
"› View Details
|
||||
Update Extension
|
||||
Enable Extension
|
||||
Uninstall Extension"
|
||||
`;
|
||||
|
||||
exports[`ActionSelectionStep Snapshots > should render for extension with update available 1`] = `
|
||||
"● View Details
|
||||
"› View Details
|
||||
Update Extension
|
||||
Disable Extension
|
||||
Uninstall Extension"
|
||||
`;
|
||||
|
||||
exports[`ActionSelectionStep Snapshots > should render with no extension selected 1`] = `
|
||||
"● View Details
|
||||
"› View Details
|
||||
Enable Extension
|
||||
Uninstall Extension"
|
||||
`;
|
||||
|
|
|
|||
|
|
@ -138,17 +138,17 @@ describe('ToolConfirmationMessage', () => {
|
|||
{
|
||||
description: 'for exec confirmations',
|
||||
details: execConfirmationDetails,
|
||||
alwaysAllowText: 'Yes, allow always',
|
||||
alwaysAllowText: 'Always allow in this project',
|
||||
},
|
||||
{
|
||||
description: 'for info confirmations',
|
||||
details: infoConfirmationDetails,
|
||||
alwaysAllowText: 'Yes, allow always',
|
||||
alwaysAllowText: 'Always allow in this project',
|
||||
},
|
||||
{
|
||||
description: 'for mcp confirmations',
|
||||
details: mcpConfirmationDetails,
|
||||
alwaysAllowText: 'always allow',
|
||||
alwaysAllowText: 'Always allow in this project',
|
||||
},
|
||||
])('$description', ({ details, alwaysAllowText }) => {
|
||||
it('should show "allow always" when folder is trusted', () => {
|
||||
|
|
|
|||
|
|
@ -242,11 +242,19 @@ export const ToolConfirmationMessage: React.FC<
|
|||
value: ToolConfirmationOutcome.ProceedOnce,
|
||||
key: 'Yes, allow once',
|
||||
});
|
||||
if (isTrustedFolder) {
|
||||
if (isTrustedFolder && !confirmationDetails.hideAlwaysAllow) {
|
||||
const rulesLabel = executionProps.permissionRules?.length
|
||||
? ` [${executionProps.permissionRules.join(', ')}]`
|
||||
: '';
|
||||
options.push({
|
||||
label: t('Yes, allow always ...'),
|
||||
value: ToolConfirmationOutcome.ProceedAlways,
|
||||
key: 'Yes, allow always ...',
|
||||
label: t('Always allow in this project') + rulesLabel,
|
||||
value: ToolConfirmationOutcome.ProceedAlwaysProject,
|
||||
key: 'Always allow in this project',
|
||||
});
|
||||
options.push({
|
||||
label: t('Always allow for this user') + rulesLabel,
|
||||
value: ToolConfirmationOutcome.ProceedAlwaysUser,
|
||||
key: 'Always allow for this user',
|
||||
});
|
||||
}
|
||||
options.push({
|
||||
|
|
@ -315,11 +323,21 @@ export const ToolConfirmationMessage: React.FC<
|
|||
value: ToolConfirmationOutcome.ProceedOnce,
|
||||
key: 'Yes, allow once',
|
||||
});
|
||||
if (isTrustedFolder) {
|
||||
if (isTrustedFolder && !confirmationDetails.hideAlwaysAllow) {
|
||||
const rulesLabel =
|
||||
'permissionRules' in infoProps &&
|
||||
(infoProps as { permissionRules?: string[] }).permissionRules?.length
|
||||
? ` [${(infoProps as { permissionRules?: string[] }).permissionRules!.join(', ')}]`
|
||||
: '';
|
||||
options.push({
|
||||
label: t('Yes, allow always'),
|
||||
value: ToolConfirmationOutcome.ProceedAlways,
|
||||
key: 'Yes, allow always',
|
||||
label: t('Always allow in this project') + rulesLabel,
|
||||
value: ToolConfirmationOutcome.ProceedAlwaysProject,
|
||||
key: 'Always allow in this project',
|
||||
});
|
||||
options.push({
|
||||
label: t('Always allow for this user') + rulesLabel,
|
||||
value: ToolConfirmationOutcome.ProceedAlwaysUser,
|
||||
key: 'Always allow for this user',
|
||||
});
|
||||
}
|
||||
options.push({
|
||||
|
|
@ -382,21 +400,19 @@ export const ToolConfirmationMessage: React.FC<
|
|||
value: ToolConfirmationOutcome.ProceedOnce,
|
||||
key: 'Yes, allow once',
|
||||
});
|
||||
if (isTrustedFolder) {
|
||||
if (isTrustedFolder && !confirmationDetails.hideAlwaysAllow) {
|
||||
const rulesLabel = mcpProps.permissionRules?.length
|
||||
? ` [${mcpProps.permissionRules.join(', ')}]`
|
||||
: '';
|
||||
options.push({
|
||||
label: t('Yes, always allow tool "{{tool}}" from server "{{server}}"', {
|
||||
tool: mcpProps.toolName,
|
||||
server: mcpProps.serverName,
|
||||
}),
|
||||
value: ToolConfirmationOutcome.ProceedAlwaysTool, // Cast until types are updated
|
||||
key: `Yes, always allow tool "${mcpProps.toolName}" from server "${mcpProps.serverName}"`,
|
||||
label: t('Always allow in this project') + rulesLabel,
|
||||
value: ToolConfirmationOutcome.ProceedAlwaysProject,
|
||||
key: 'Always allow in this project',
|
||||
});
|
||||
options.push({
|
||||
label: t('Yes, always allow all tools from server "{{server}}"', {
|
||||
server: mcpProps.serverName,
|
||||
}),
|
||||
value: ToolConfirmationOutcome.ProceedAlwaysServer,
|
||||
key: `Yes, always allow all tools from server "${mcpProps.serverName}"`,
|
||||
label: t('Always allow for this user') + rulesLabel,
|
||||
value: ToolConfirmationOutcome.ProceedAlwaysUser,
|
||||
key: 'Always allow for this user',
|
||||
});
|
||||
}
|
||||
options.push({
|
||||
|
|
|
|||
|
|
@ -93,12 +93,12 @@ describe('BaseSelectionList', () => {
|
|||
expect(mockRenderItem).toHaveBeenCalledWith(items[0], expect.any(Object));
|
||||
});
|
||||
|
||||
it('should render the selection indicator (● or space) and layout', () => {
|
||||
it('should render the selection indicator (› or space) and layout', () => {
|
||||
const { lastFrame } = renderComponent({}, 0);
|
||||
const output = lastFrame();
|
||||
|
||||
// Use regex to assert the structure: Indicator + Whitespace + Number + Label
|
||||
expect(output).toMatch(/●\s+1\.\s+Item A/);
|
||||
expect(output).toMatch(/›\s+1\.\s+Item A/);
|
||||
expect(output).toMatch(/\s+2\.\s+Item B/);
|
||||
expect(output).toMatch(/\s+3\.\s+Item C/);
|
||||
});
|
||||
|
|
|
|||
|
|
@ -138,7 +138,7 @@ export function BaseSelectionList<
|
|||
color={isSelected ? theme.status.success : theme.text.primary}
|
||||
aria-hidden
|
||||
>
|
||||
{isSelected ? '●' : ' '}
|
||||
{isSelected ? '›' : ' '}
|
||||
</Text>
|
||||
</Box>
|
||||
|
||||
|
|
|
|||
|
|
@ -21,6 +21,12 @@ export interface TextInputProps {
|
|||
value: string;
|
||||
onChange: (text: string) => void;
|
||||
onSubmit?: () => void;
|
||||
/** Called when Tab is pressed; if provided, prevents the default tab-insertion behaviour. */
|
||||
onTab?: () => void;
|
||||
/** Called when ↑ is pressed; if provided, prevents cursor-up in the buffer. */
|
||||
onUp?: () => void;
|
||||
/** Called when ↓ is pressed; if provided, prevents cursor-down in the buffer. */
|
||||
onDown?: () => void;
|
||||
placeholder?: string;
|
||||
height?: number; // lines in viewport; >1 enables multiline
|
||||
isActive?: boolean; // when false, ignore keypresses
|
||||
|
|
@ -33,6 +39,9 @@ export function TextInput({
|
|||
value,
|
||||
onChange,
|
||||
onSubmit,
|
||||
onTab,
|
||||
onUp,
|
||||
onDown,
|
||||
placeholder,
|
||||
height = 1,
|
||||
isActive = true,
|
||||
|
|
@ -68,6 +77,22 @@ export function TextInput({
|
|||
(key: Key) => {
|
||||
if (!buffer || !isActive) return;
|
||||
|
||||
// Tab completion: delegate to caller instead of inserting a tab character
|
||||
if (key.name === 'tab') {
|
||||
onTab?.();
|
||||
return;
|
||||
}
|
||||
|
||||
// Arrow-key completion navigation: delegate to caller
|
||||
if (key.name === 'up' && onUp) {
|
||||
onUp();
|
||||
return;
|
||||
}
|
||||
if (key.name === 'down' && onDown) {
|
||||
onDown();
|
||||
return;
|
||||
}
|
||||
|
||||
// Submit on Enter
|
||||
if (keyMatchers[Command.SUBMIT](key) || key.name === 'return') {
|
||||
if (allowMultiline) {
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ exports[`DescriptiveRadioButtonSelect > should render correctly with custom prop
|
|||
"▲
|
||||
1. Foo Title
|
||||
This is Foo.
|
||||
● 2. Bar Title
|
||||
› 2. Bar Title
|
||||
This is Bar.
|
||||
3. Baz Title
|
||||
This is Baz.
|
||||
|
|
@ -12,7 +12,7 @@ exports[`DescriptiveRadioButtonSelect > should render correctly with custom prop
|
|||
`;
|
||||
|
||||
exports[`DescriptiveRadioButtonSelect > should render correctly with default props 1`] = `
|
||||
"● Foo Title
|
||||
"› Foo Title
|
||||
This is Foo.
|
||||
Bar Title
|
||||
This is Bar.
|
||||
|
|
|
|||
|
|
@ -59,6 +59,7 @@ export interface UIActions {
|
|||
closeArenaDialog: () => void;
|
||||
handleArenaModelsSelected?: (models: string[]) => void;
|
||||
dismissCodingPlanUpdate: () => void;
|
||||
closeTrustDialog: () => void;
|
||||
closePermissionsDialog: () => void;
|
||||
setShellModeActive: (value: boolean) => void;
|
||||
vimHandleInput: (key: Key) => boolean;
|
||||
|
|
|
|||
|
|
@ -53,6 +53,7 @@ export interface UIState {
|
|||
quittingMessages: HistoryItem[] | null;
|
||||
isSettingsDialogOpen: boolean;
|
||||
isModelDialogOpen: boolean;
|
||||
isTrustDialogOpen: boolean;
|
||||
activeArenaDialog: ArenaDialogType;
|
||||
isPermissionsDialogOpen: boolean;
|
||||
isApprovalModeDialogOpen: boolean;
|
||||
|
|
|
|||
|
|
@ -156,6 +156,7 @@ describe('useSlashCommandProcessor', () => {
|
|||
openEditorDialog: vi.fn(),
|
||||
openSettingsDialog: vi.fn(),
|
||||
openModelDialog: mockOpenModelDialog,
|
||||
openTrustDialog: vi.fn(),
|
||||
openPermissionsDialog: vi.fn(),
|
||||
openApprovalModeDialog: vi.fn(),
|
||||
openResumeDialog: vi.fn(),
|
||||
|
|
@ -929,6 +930,7 @@ describe('useSlashCommandProcessor', () => {
|
|||
openEditorDialog: vi.fn(),
|
||||
openSettingsDialog: vi.fn(),
|
||||
openModelDialog: vi.fn(),
|
||||
openTrustDialog: vi.fn(),
|
||||
openPermissionsDialog: vi.fn(),
|
||||
openApprovalModeDialog: vi.fn(),
|
||||
openResumeDialog: vi.fn(),
|
||||
|
|
|
|||
|
|
@ -72,6 +72,7 @@ interface SlashCommandProcessorActions {
|
|||
openEditorDialog: () => void;
|
||||
openSettingsDialog: () => void;
|
||||
openModelDialog: () => void;
|
||||
openTrustDialog: () => void;
|
||||
openPermissionsDialog: () => void;
|
||||
openApprovalModeDialog: () => void;
|
||||
openResumeDialog: () => void;
|
||||
|
|
@ -485,6 +486,9 @@ export const useSlashCommandProcessor = (
|
|||
case 'model':
|
||||
actions.openModelDialog();
|
||||
return { type: 'handled' };
|
||||
case 'trust':
|
||||
actions.openTrustDialog();
|
||||
return { type: 'handled' };
|
||||
case 'permissions':
|
||||
actions.openPermissionsDialog();
|
||||
return { type: 'handled' };
|
||||
|
|
|
|||
|
|
@ -11,6 +11,11 @@ import {
|
|||
AttentionNotificationReason,
|
||||
} from '../../utils/attentionNotification.js';
|
||||
import type { LoadedSettings } from '../../config/settings.js';
|
||||
import type { Config } from '@qwen-code/qwen-code-core';
|
||||
import {
|
||||
fireNotificationHook,
|
||||
NotificationType,
|
||||
} from '@qwen-code/qwen-code-core';
|
||||
|
||||
export const LONG_TASK_NOTIFICATION_THRESHOLD_SECONDS = 20;
|
||||
|
||||
|
|
@ -19,6 +24,7 @@ interface UseAttentionNotificationsOptions {
|
|||
streamingState: StreamingState;
|
||||
elapsedTime: number;
|
||||
settings: LoadedSettings;
|
||||
config?: Config;
|
||||
}
|
||||
|
||||
export const useAttentionNotifications = ({
|
||||
|
|
@ -26,10 +32,12 @@ export const useAttentionNotifications = ({
|
|||
streamingState,
|
||||
elapsedTime,
|
||||
settings,
|
||||
config,
|
||||
}: UseAttentionNotificationsOptions) => {
|
||||
const terminalBellEnabled = settings?.merged?.general?.terminalBell ?? true;
|
||||
const awaitingNotificationSentRef = useRef(false);
|
||||
const respondingElapsedRef = useRef(0);
|
||||
const idleNotificationSentRef = useRef(false);
|
||||
|
||||
useEffect(() => {
|
||||
if (
|
||||
|
|
@ -51,6 +59,8 @@ export const useAttentionNotifications = ({
|
|||
useEffect(() => {
|
||||
if (streamingState === StreamingState.Responding) {
|
||||
respondingElapsedRef.current = elapsedTime;
|
||||
// Reset idle notification flag when responding
|
||||
idleNotificationSentRef.current = false;
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -65,7 +75,28 @@ export const useAttentionNotifications = ({
|
|||
}
|
||||
// Reset tracking for next task
|
||||
respondingElapsedRef.current = 0;
|
||||
|
||||
// Fire idle_prompt notification hook when entering idle state
|
||||
if (config && !idleNotificationSentRef.current) {
|
||||
const messageBus = config.getMessageBus();
|
||||
const hooksEnabled = config.getEnableHooks();
|
||||
if (hooksEnabled && messageBus) {
|
||||
fireNotificationHook(
|
||||
messageBus,
|
||||
'Qwen Code is waiting for your input',
|
||||
NotificationType.IdlePrompt,
|
||||
'Waiting for input',
|
||||
).catch(() => {
|
||||
// Silently ignore errors - fireNotificationHook has internal error handling
|
||||
// and notification hooks should not block the idle flow
|
||||
});
|
||||
}
|
||||
idleNotificationSentRef.current = true;
|
||||
}
|
||||
return;
|
||||
}
|
||||
}, [streamingState, elapsedTime, isFocused, terminalBellEnabled]);
|
||||
|
||||
// Reset idle notification flag when in WaitingForConfirmation state
|
||||
idleNotificationSentRef.current = false;
|
||||
}, [streamingState, elapsedTime, isFocused, terminalBellEnabled, config]);
|
||||
};
|
||||
|
|
|
|||
|
|
@ -142,6 +142,11 @@ describe('useResumeCommand', () => {
|
|||
getTargetDir: () => '/tmp',
|
||||
getGeminiClient: () => geminiClient,
|
||||
startNewSession: vi.fn(),
|
||||
getDebugLogger: () => ({
|
||||
warn: vi.fn(),
|
||||
debug: vi.fn(),
|
||||
error: vi.fn(),
|
||||
}),
|
||||
} as unknown as import('@qwen-code/qwen-code-core').Config;
|
||||
|
||||
const { result } = renderHook(() =>
|
||||
|
|
|
|||
|
|
@ -5,7 +5,11 @@
|
|||
*/
|
||||
|
||||
import { useState, useCallback } from 'react';
|
||||
import { SessionService, type Config } from '@qwen-code/qwen-code-core';
|
||||
import {
|
||||
SessionService,
|
||||
type Config,
|
||||
SessionStartSource,
|
||||
} from '@qwen-code/qwen-code-core';
|
||||
import { buildResumedHistoryItems } from '../utils/resumeHistoryUtils.js';
|
||||
import type { UseHistoryManagerReturn } from './useHistoryManager.js';
|
||||
|
||||
|
|
@ -67,6 +71,18 @@ export function useResumeCommand(
|
|||
config.startNewSession(sessionId, sessionData);
|
||||
await config.getGeminiClient()?.initialize?.();
|
||||
|
||||
// Fire SessionStart event after resuming session
|
||||
try {
|
||||
await config
|
||||
.getHookSystem()
|
||||
?.fireSessionStartEvent(
|
||||
SessionStartSource.Resume,
|
||||
config.getModel() ?? '',
|
||||
);
|
||||
} catch (err) {
|
||||
config.getDebugLogger().warn(`SessionStart hook failed: ${err}`);
|
||||
}
|
||||
|
||||
// Refresh terminal UI.
|
||||
remount?.();
|
||||
},
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ const mockConfig = {
|
|||
},
|
||||
getTruncateToolOutputThreshold: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD,
|
||||
getTruncateToolOutputLines: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES,
|
||||
getAllowedTools: vi.fn(() => []),
|
||||
getPermissionsAllow: vi.fn(() => []),
|
||||
getContentGeneratorConfig: () => ({
|
||||
model: 'test-model',
|
||||
authType: 'gemini',
|
||||
|
|
@ -68,30 +68,29 @@ const mockConfig = {
|
|||
getGeminiClient: () => null, // No client needed for these tests
|
||||
getShellExecutionConfig: () => ({ terminalWidth: 80, terminalHeight: 24 }),
|
||||
getChatRecordingService: () => undefined,
|
||||
getMessageBus: vi.fn().mockReturnValue(undefined),
|
||||
getEnableHooks: vi.fn().mockReturnValue(false),
|
||||
getHookSystem: vi.fn().mockReturnValue(undefined),
|
||||
getDebugLogger: vi.fn().mockReturnValue({
|
||||
debug: vi.fn(),
|
||||
info: vi.fn(),
|
||||
warn: vi.fn(),
|
||||
error: vi.fn(),
|
||||
}),
|
||||
} as unknown as Config;
|
||||
|
||||
const mockTool = new MockTool({
|
||||
name: 'mockTool',
|
||||
displayName: 'Mock Tool',
|
||||
execute: vi.fn(),
|
||||
shouldConfirmExecute: vi.fn(),
|
||||
});
|
||||
const mockToolWithLiveOutput = new MockTool({
|
||||
name: 'mockToolWithLiveOutput',
|
||||
displayName: 'Mock Tool With Live Output',
|
||||
description: 'A mock tool for testing',
|
||||
params: {},
|
||||
isOutputMarkdown: true,
|
||||
canUpdateOutput: true,
|
||||
execute: vi.fn(),
|
||||
shouldConfirmExecute: vi.fn(),
|
||||
});
|
||||
let mockOnUserConfirmForToolConfirmation: Mock;
|
||||
const mockToolRequiresConfirmation = new MockTool({
|
||||
name: 'mockToolRequiresConfirmation',
|
||||
displayName: 'Mock Tool Requires Confirmation',
|
||||
execute: vi.fn(),
|
||||
shouldConfirmExecute: vi.fn(),
|
||||
getDefaultPermission: () => Promise.resolve('ask' as any),
|
||||
getConfirmationDetails: vi.fn(),
|
||||
});
|
||||
|
||||
describe('useReactToolScheduler in YOLO Mode', () => {
|
||||
|
|
@ -103,7 +102,7 @@ describe('useReactToolScheduler in YOLO Mode', () => {
|
|||
setPendingHistoryItem = vi.fn();
|
||||
mockToolRegistry.getTool.mockClear();
|
||||
(mockToolRequiresConfirmation.execute as Mock).mockClear();
|
||||
(mockToolRequiresConfirmation.shouldConfirmExecute as Mock).mockClear();
|
||||
(mockToolRequiresConfirmation.getConfirmationDetails as Mock).mockClear();
|
||||
|
||||
// IMPORTANT: Enable YOLO mode for this test suite
|
||||
(mockConfig.getApprovalMode as Mock).mockReturnValue(ApprovalMode.YOLO);
|
||||
|
|
@ -209,17 +208,14 @@ describe('useReactToolScheduler', () => {
|
|||
|
||||
mockToolRegistry.getTool.mockClear();
|
||||
(mockTool.execute as Mock).mockClear();
|
||||
(mockTool.shouldConfirmExecute as Mock).mockClear();
|
||||
(mockToolWithLiveOutput.execute as Mock).mockClear();
|
||||
(mockToolWithLiveOutput.shouldConfirmExecute as Mock).mockClear();
|
||||
(mockToolRequiresConfirmation.execute as Mock).mockClear();
|
||||
(mockToolRequiresConfirmation.shouldConfirmExecute as Mock).mockClear();
|
||||
(mockToolRequiresConfirmation.getConfirmationDetails as Mock).mockClear();
|
||||
|
||||
mockOnUserConfirmForToolConfirmation = vi.fn();
|
||||
(
|
||||
mockToolRequiresConfirmation.shouldConfirmExecute as Mock
|
||||
mockToolRequiresConfirmation.getConfirmationDetails as Mock
|
||||
).mockImplementation(
|
||||
async (): Promise<ToolCallConfirmationDetails | null> =>
|
||||
async (): Promise<ToolCallConfirmationDetails> =>
|
||||
({
|
||||
onConfirm: mockOnUserConfirmForToolConfirmation,
|
||||
fileName: 'mockToolRequiresConfirmation.ts',
|
||||
|
|
@ -258,7 +254,6 @@ describe('useReactToolScheduler', () => {
|
|||
llmContent: 'Tool output',
|
||||
returnDisplay: 'Formatted tool output',
|
||||
} as ToolResult);
|
||||
(mockTool.shouldConfirmExecute as Mock).mockResolvedValue(null);
|
||||
|
||||
const { result } = renderScheduler();
|
||||
const schedule = result.current[1];
|
||||
|
|
@ -343,10 +338,11 @@ describe('useReactToolScheduler', () => {
|
|||
expect(result.current[0]).toEqual([]);
|
||||
});
|
||||
|
||||
it('should handle error during shouldConfirmExecute', async () => {
|
||||
it('should handle error during getDefaultPermission', async () => {
|
||||
mockToolRegistry.getTool.mockReturnValue(mockTool);
|
||||
const confirmError = new Error('Confirmation check failed');
|
||||
(mockTool.shouldConfirmExecute as Mock).mockRejectedValue(confirmError);
|
||||
const originalGetDefaultPermission = mockTool.getDefaultPermission;
|
||||
mockTool.getDefaultPermission = () => Promise.reject(confirmError);
|
||||
|
||||
const { result } = renderScheduler();
|
||||
const schedule = result.current[1];
|
||||
|
|
@ -376,11 +372,11 @@ describe('useReactToolScheduler', () => {
|
|||
}),
|
||||
]);
|
||||
expect(result.current[0]).toEqual([]);
|
||||
mockTool.getDefaultPermission = originalGetDefaultPermission;
|
||||
});
|
||||
|
||||
it('should handle error during execute', async () => {
|
||||
mockToolRegistry.getTool.mockReturnValue(mockTool);
|
||||
(mockTool.shouldConfirmExecute as Mock).mockResolvedValue(null);
|
||||
const execError = new Error('Execution failed');
|
||||
(mockTool.execute as Mock).mockRejectedValue(execError);
|
||||
|
||||
|
|
@ -523,7 +519,6 @@ describe('mapToDisplay', () => {
|
|||
name: 'testTool',
|
||||
displayName: 'Test Tool Display',
|
||||
execute: vi.fn(),
|
||||
shouldConfirmExecute: vi.fn(),
|
||||
});
|
||||
|
||||
const baseResponse: ToolCallResponseInfo = {
|
||||
|
|
@ -758,7 +753,6 @@ describe('mapToDisplay', () => {
|
|||
displayName: baseTool.displayName,
|
||||
isOutputMarkdown: true,
|
||||
execute: vi.fn(),
|
||||
shouldConfirmExecute: vi.fn(),
|
||||
});
|
||||
const toolCall2: ToolCall = {
|
||||
request: { ...baseRequest, callId: 'call2' },
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ import {
|
|||
type Mock,
|
||||
} from 'vitest';
|
||||
import { renderHook, act } from '@testing-library/react';
|
||||
import { usePermissionsModifyTrust } from './usePermissionsModifyTrust.js';
|
||||
import { useTrustModify } from './useTrustModify.js';
|
||||
import { TrustLevel } from '../../config/trustedFolders.js';
|
||||
import type { LoadedSettings } from '../../config/settings.js';
|
||||
import type { LoadedTrustedFolders } from '../../config/trustedFolders.js';
|
||||
|
|
@ -46,7 +46,7 @@ vi.mock('../contexts/SettingsContext.js', () => ({
|
|||
useSettings: mockedUseSettings,
|
||||
}));
|
||||
|
||||
describe('usePermissionsModifyTrust', () => {
|
||||
describe('useTrustModify', () => {
|
||||
let mockOnExit: Mock;
|
||||
let mockAddItem: Mock;
|
||||
|
||||
|
|
@ -84,7 +84,7 @@ describe('usePermissionsModifyTrust', () => {
|
|||
});
|
||||
|
||||
const { result } = renderHook(() =>
|
||||
usePermissionsModifyTrust(mockOnExit, mockAddItem),
|
||||
useTrustModify(mockOnExit, mockAddItem),
|
||||
);
|
||||
|
||||
expect(result.current.currentTrustLevel).toBe(TrustLevel.TRUST_FOLDER);
|
||||
|
|
@ -101,7 +101,7 @@ describe('usePermissionsModifyTrust', () => {
|
|||
});
|
||||
|
||||
const { result } = renderHook(() =>
|
||||
usePermissionsModifyTrust(mockOnExit, mockAddItem),
|
||||
useTrustModify(mockOnExit, mockAddItem),
|
||||
);
|
||||
|
||||
expect(result.current.isInheritedTrustFromParent).toBe(true);
|
||||
|
|
@ -118,7 +118,7 @@ describe('usePermissionsModifyTrust', () => {
|
|||
});
|
||||
|
||||
const { result } = renderHook(() =>
|
||||
usePermissionsModifyTrust(mockOnExit, mockAddItem),
|
||||
useTrustModify(mockOnExit, mockAddItem),
|
||||
);
|
||||
|
||||
expect(result.current.isInheritedTrustFromIde).toBe(true);
|
||||
|
|
@ -137,7 +137,7 @@ describe('usePermissionsModifyTrust', () => {
|
|||
.mockReturnValueOnce({ isTrusted: true, source: 'file' });
|
||||
|
||||
const { result } = renderHook(() =>
|
||||
usePermissionsModifyTrust(mockOnExit, mockAddItem),
|
||||
useTrustModify(mockOnExit, mockAddItem),
|
||||
);
|
||||
|
||||
act(() => {
|
||||
|
|
@ -161,7 +161,7 @@ describe('usePermissionsModifyTrust', () => {
|
|||
});
|
||||
|
||||
const { result } = renderHook(() =>
|
||||
usePermissionsModifyTrust(mockOnExit, mockAddItem),
|
||||
useTrustModify(mockOnExit, mockAddItem),
|
||||
);
|
||||
|
||||
act(() => {
|
||||
|
|
@ -188,7 +188,7 @@ describe('usePermissionsModifyTrust', () => {
|
|||
.mockReturnValueOnce({ isTrusted: true, source: 'file' });
|
||||
|
||||
const { result } = renderHook(() =>
|
||||
usePermissionsModifyTrust(mockOnExit, mockAddItem),
|
||||
useTrustModify(mockOnExit, mockAddItem),
|
||||
);
|
||||
|
||||
act(() => {
|
||||
|
|
@ -218,7 +218,7 @@ describe('usePermissionsModifyTrust', () => {
|
|||
});
|
||||
|
||||
const { result } = renderHook(() =>
|
||||
usePermissionsModifyTrust(mockOnExit, mockAddItem),
|
||||
useTrustModify(mockOnExit, mockAddItem),
|
||||
);
|
||||
|
||||
act(() => {
|
||||
|
|
@ -245,7 +245,7 @@ describe('usePermissionsModifyTrust', () => {
|
|||
});
|
||||
|
||||
const { result } = renderHook(() =>
|
||||
usePermissionsModifyTrust(mockOnExit, mockAddItem),
|
||||
useTrustModify(mockOnExit, mockAddItem),
|
||||
);
|
||||
|
||||
act(() => {
|
||||
|
|
@ -42,7 +42,7 @@ function getInitialTrustState(
|
|||
};
|
||||
}
|
||||
|
||||
export const usePermissionsModifyTrust = (
|
||||
export const useTrustModify = (
|
||||
onExit: () => void,
|
||||
addItem: UseHistoryManagerReturn['addItem'],
|
||||
) => {
|
||||
|
|
@ -6,10 +6,395 @@
|
|||
|
||||
import { randomUUID } from 'node:crypto';
|
||||
import type { Config, ChatRecord } from '@qwen-code/qwen-code-core';
|
||||
import type { GenerateContentResponseUsageMetadata } from '@google/genai';
|
||||
import type { SessionContext } from '../../../acp-integration/session/types.js';
|
||||
import type { SessionUpdate, ToolCall } from '@agentclientprotocol/sdk';
|
||||
import { HistoryReplayer } from '../../../acp-integration/session/HistoryReplayer.js';
|
||||
import type { ExportMessage, ExportSessionData } from './types.js';
|
||||
import type {
|
||||
ExportMessage,
|
||||
ExportSessionData,
|
||||
ExportMetadata,
|
||||
} from './types.js';
|
||||
|
||||
/**
|
||||
* File operation statistics extracted from tool calls.
|
||||
*/
|
||||
interface FileOperationStats {
|
||||
filesWritten: number;
|
||||
linesAdded: number;
|
||||
linesRemoved: number;
|
||||
writtenFilePaths: Set<string>;
|
||||
}
|
||||
|
||||
/**
|
||||
* Tool call arguments index for matching tool_result records.
|
||||
*/
|
||||
interface ToolCallArgsIndex {
|
||||
byId: Map<string, Record<string, unknown>>;
|
||||
byName: Map<string, Array<Record<string, unknown>>>;
|
||||
}
|
||||
|
||||
/**
|
||||
* Extracts tool name from a ChatRecord's function response.
|
||||
*/
|
||||
function extractToolNameFromRecord(record: ChatRecord): string | undefined {
|
||||
if (!record.message?.parts) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
for (const part of record.message.parts) {
|
||||
if ('functionResponse' in part && part.functionResponse?.name) {
|
||||
return part.functionResponse.name;
|
||||
}
|
||||
}
|
||||
|
||||
return undefined;
|
||||
}
|
||||
|
||||
/**
|
||||
* Extracts call ID from a ChatRecord's function response.
|
||||
*/
|
||||
function extractFunctionResponseId(record: ChatRecord): string | undefined {
|
||||
if (!record.message?.parts) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
for (const part of record.message.parts) {
|
||||
if ('functionResponse' in part && part.functionResponse?.id) {
|
||||
return part.functionResponse.id;
|
||||
}
|
||||
}
|
||||
|
||||
return undefined;
|
||||
}
|
||||
|
||||
/**
|
||||
* Normalizes function call args into a plain object.
|
||||
*/
|
||||
function normalizeFunctionCallArgs(
|
||||
args: unknown,
|
||||
): Record<string, unknown> | undefined {
|
||||
if (args && typeof args === 'object') {
|
||||
return args as Record<string, unknown>;
|
||||
}
|
||||
if (typeof args === 'string') {
|
||||
try {
|
||||
const parsed = JSON.parse(args) as unknown;
|
||||
if (parsed && typeof parsed === 'object') {
|
||||
return parsed as Record<string, unknown>;
|
||||
}
|
||||
} catch {
|
||||
// Ignore parse errors and treat as unavailable args
|
||||
}
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds an index of assistant tool calls for later tool_result arg resolution.
|
||||
*/
|
||||
function buildToolCallArgsIndex(records: ChatRecord[]): ToolCallArgsIndex {
|
||||
const byId = new Map<string, Record<string, unknown>>();
|
||||
const byName = new Map<string, Array<Record<string, unknown>>>();
|
||||
|
||||
for (const record of records) {
|
||||
if (record.type !== 'assistant' || !record.message?.parts) continue;
|
||||
|
||||
for (const part of record.message.parts) {
|
||||
if (!('functionCall' in part) || !part.functionCall?.name) continue;
|
||||
|
||||
const normalizedArgs = normalizeFunctionCallArgs(part.functionCall.args);
|
||||
if (!normalizedArgs) continue;
|
||||
|
||||
const toolName = part.functionCall.name;
|
||||
const callId =
|
||||
typeof part.functionCall.id === 'string' ? part.functionCall.id : null;
|
||||
|
||||
if (callId) {
|
||||
byId.set(callId, normalizedArgs);
|
||||
}
|
||||
|
||||
const queue = byName.get(toolName) ?? [];
|
||||
queue.push(normalizedArgs);
|
||||
byName.set(toolName, queue);
|
||||
}
|
||||
}
|
||||
|
||||
return { byId, byName };
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate file operation statistics from ChatRecords.
|
||||
* Uses toolCallResult from tool_result records for accurate statistics.
|
||||
*/
|
||||
function calculateFileStats(records: ChatRecord[]): FileOperationStats {
|
||||
const argsIndex = buildToolCallArgsIndex(records);
|
||||
const byNameCursor = new Map<string, number>();
|
||||
|
||||
const stats: FileOperationStats = {
|
||||
filesWritten: 0,
|
||||
linesAdded: 0,
|
||||
linesRemoved: 0,
|
||||
writtenFilePaths: new Set(),
|
||||
};
|
||||
|
||||
for (const record of records) {
|
||||
if (record.type !== 'tool_result' || !record.toolCallResult) continue;
|
||||
|
||||
const toolName = extractToolNameFromRecord(record);
|
||||
const callId =
|
||||
record.toolCallResult.callId ?? extractFunctionResponseId(record);
|
||||
const argsFromId =
|
||||
callId && argsIndex.byId.has(callId)
|
||||
? argsIndex.byId.get(callId)
|
||||
: undefined;
|
||||
let args = argsFromId;
|
||||
if (!args && toolName) {
|
||||
const queue = argsIndex.byName.get(toolName);
|
||||
if (queue && queue.length > 0) {
|
||||
const cursor = byNameCursor.get(toolName) ?? 0;
|
||||
args = queue[cursor];
|
||||
byNameCursor.set(toolName, cursor + 1);
|
||||
}
|
||||
}
|
||||
const { resultDisplay } = record.toolCallResult;
|
||||
|
||||
// Track file locations from resultDisplay
|
||||
if (
|
||||
resultDisplay &&
|
||||
typeof resultDisplay === 'object' &&
|
||||
'fileName' in resultDisplay
|
||||
) {
|
||||
const display = resultDisplay as {
|
||||
fileName: string;
|
||||
fileDiff?: string;
|
||||
originalContent?: string | null;
|
||||
newContent?: string;
|
||||
diffStat?: { model_added_lines?: number; model_removed_lines?: number };
|
||||
};
|
||||
|
||||
// Determine operation type based on content fields
|
||||
const hasOriginalContent = 'originalContent' in display;
|
||||
const hasNewContent = 'newContent' in display;
|
||||
|
||||
// For write/edit operations, use full path from args if available
|
||||
let filePath: string;
|
||||
if (typeof display.fileName === 'string') {
|
||||
// Prefer args.file_path for full path, fallback to fileName (which may be basename)
|
||||
filePath =
|
||||
(args?.['file_path'] as string) ||
|
||||
(args?.['absolute_path'] as string) ||
|
||||
display.fileName;
|
||||
} else {
|
||||
// Fallback if fileName is not a string
|
||||
filePath = 'unknown';
|
||||
}
|
||||
|
||||
if (hasOriginalContent || hasNewContent) {
|
||||
// This is a write/edit operation
|
||||
stats.filesWritten++;
|
||||
stats.writtenFilePaths.add(filePath);
|
||||
|
||||
// Calculate line changes
|
||||
if (display.diffStat) {
|
||||
// Use diffStat if available for accurate counts
|
||||
stats.linesAdded += display.diffStat.model_added_lines ?? 0;
|
||||
stats.linesRemoved += display.diffStat.model_removed_lines ?? 0;
|
||||
} else {
|
||||
// Fallback: count lines in content
|
||||
const oldText = String(display.originalContent ?? '');
|
||||
const newText = String(display.newContent ?? '');
|
||||
|
||||
// Count non-empty lines
|
||||
const oldLines = oldText
|
||||
.split('\n')
|
||||
.filter((line) => line.length > 0).length;
|
||||
const newLines = newText
|
||||
.split('\n')
|
||||
.filter((line) => line.length > 0).length;
|
||||
|
||||
stats.linesAdded += newLines;
|
||||
stats.linesRemoved += oldLines;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return stats;
|
||||
}
|
||||
|
||||
/**
|
||||
* Extracts token usage from TaskResultDisplay executionSummary.
|
||||
*/
|
||||
function extractTaskToolTokens(record: ChatRecord): number {
|
||||
if (record.type !== 'tool_result' || !record.toolCallResult?.resultDisplay) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
const { resultDisplay } = record.toolCallResult;
|
||||
if (
|
||||
typeof resultDisplay === 'object' &&
|
||||
'type' in resultDisplay &&
|
||||
resultDisplay.type === 'task_execution' &&
|
||||
'executionSummary' in resultDisplay
|
||||
) {
|
||||
const summary = resultDisplay.executionSummary as {
|
||||
totalTokens?: number;
|
||||
inputTokens?: number;
|
||||
outputTokens?: number;
|
||||
thoughtTokens?: number;
|
||||
cachedTokens?: number;
|
||||
};
|
||||
// Use totalTokens if available, otherwise sum individual token counts
|
||||
if (typeof summary.totalTokens === 'number') {
|
||||
return summary.totalTokens;
|
||||
}
|
||||
// Fallback: sum available token counts
|
||||
return (
|
||||
(summary.inputTokens ?? 0) +
|
||||
(summary.outputTokens ?? 0) +
|
||||
(summary.thoughtTokens ?? 0) +
|
||||
(summary.cachedTokens ?? 0)
|
||||
);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate token statistics from ChatRecords.
|
||||
* Aggregates usageMetadata from assistant records and TaskTool executionSummary to get total token usage.
|
||||
* Uses the last assistant record that has both totalTokenCount and contextWindowSize for calculating context usage percent.
|
||||
*/
|
||||
function calculateTokenStats(records: ChatRecord[]): {
|
||||
totalTokens: number;
|
||||
contextUsagePercent?: number;
|
||||
contextWindowSize?: number;
|
||||
} {
|
||||
let totalTokens = 0;
|
||||
// Track the last assistant record that has BOTH totalTokenCount and contextWindowSize
|
||||
// to ensure the percentage calculation uses values from the same record
|
||||
let lastValidRecord: {
|
||||
totalTokenCount: number;
|
||||
contextWindowSize: number;
|
||||
} | null = null;
|
||||
|
||||
// Aggregate usageMetadata from all assistant records
|
||||
for (const record of records) {
|
||||
if (record.type === 'assistant') {
|
||||
if (record.usageMetadata) {
|
||||
totalTokens += record.usageMetadata.totalTokenCount ?? 0;
|
||||
}
|
||||
// Only update lastValidRecord when BOTH values are present in the same record
|
||||
if (
|
||||
record.usageMetadata?.totalTokenCount !== undefined &&
|
||||
record.contextWindowSize !== undefined
|
||||
) {
|
||||
lastValidRecord = {
|
||||
totalTokenCount: record.usageMetadata.totalTokenCount,
|
||||
contextWindowSize: record.contextWindowSize,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// Include TaskTool token usage from executionSummary
|
||||
const taskTokens = extractTaskToolTokens(record);
|
||||
if (taskTokens > 0) {
|
||||
totalTokens += taskTokens;
|
||||
}
|
||||
}
|
||||
|
||||
// Use last valid record's values for context usage calculation
|
||||
// This represents how much of the context window is being used by the total tokens
|
||||
if (lastValidRecord) {
|
||||
const percent =
|
||||
(lastValidRecord.totalTokenCount / lastValidRecord.contextWindowSize) *
|
||||
100;
|
||||
return {
|
||||
totalTokens,
|
||||
contextUsagePercent: Math.round(percent * 10) / 10,
|
||||
contextWindowSize: lastValidRecord.contextWindowSize,
|
||||
};
|
||||
}
|
||||
|
||||
// Fallback: return the contextWindowSize from the last assistant record even if no valid pair found
|
||||
// (for display purposes only, without percentage)
|
||||
const lastAssistantRecord = [...records]
|
||||
.reverse()
|
||||
.find((r) => r.type === 'assistant' && r.contextWindowSize !== undefined);
|
||||
|
||||
return {
|
||||
totalTokens,
|
||||
contextWindowSize: lastAssistantRecord?.contextWindowSize,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract session metadata from ChatRecords.
|
||||
*/
|
||||
async function extractMetadata(
|
||||
conversation: {
|
||||
sessionId: string;
|
||||
startTime: string;
|
||||
messages: ChatRecord[];
|
||||
},
|
||||
config: Config,
|
||||
): Promise<ExportMetadata> {
|
||||
const { sessionId, startTime, messages } = conversation;
|
||||
|
||||
// Extract basic info from the first record
|
||||
const firstRecord = messages[0];
|
||||
const cwd = firstRecord?.cwd ?? '';
|
||||
const gitBranch = firstRecord?.gitBranch;
|
||||
|
||||
// Get git repository name
|
||||
let gitRepo: string | undefined;
|
||||
if (cwd) {
|
||||
const { getGitRepoName } = await import('@qwen-code/qwen-code-core');
|
||||
gitRepo = getGitRepoName(cwd);
|
||||
}
|
||||
|
||||
// Try to get model from assistant messages
|
||||
let model: string | undefined;
|
||||
for (const record of messages) {
|
||||
if (record.type === 'assistant' && record.model) {
|
||||
model = record.model;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Get channel from config
|
||||
const channel = config.getChannel?.();
|
||||
|
||||
// Count user prompts
|
||||
const promptCount = messages.filter((m) => m.type === 'user').length;
|
||||
|
||||
// Calculate file stats from original ChatRecords
|
||||
const fileStats = calculateFileStats(messages);
|
||||
|
||||
// Calculate token stats from original ChatRecords
|
||||
// contextWindowSize is retrieved from the last assistant record for accuracy
|
||||
const tokenStats = calculateTokenStats(messages);
|
||||
|
||||
return {
|
||||
sessionId,
|
||||
startTime,
|
||||
exportTime: new Date().toISOString(),
|
||||
cwd,
|
||||
gitRepo,
|
||||
gitBranch,
|
||||
model,
|
||||
channel,
|
||||
promptCount,
|
||||
contextUsagePercent: tokenStats.contextUsagePercent,
|
||||
contextWindowSize: tokenStats.contextWindowSize,
|
||||
totalTokens: tokenStats.totalTokens,
|
||||
filesWritten: fileStats.writtenFilePaths.size,
|
||||
linesAdded: fileStats.linesAdded,
|
||||
linesRemoved: fileStats.linesRemoved,
|
||||
uniqueFiles: Array.from(fileStats.writtenFilePaths),
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Export session context that captures session updates into export messages.
|
||||
|
|
@ -24,6 +409,7 @@ class ExportSessionContext implements SessionContext {
|
|||
role: 'user' | 'assistant' | 'thinking';
|
||||
parts: Array<{ text: string }>;
|
||||
timestamp: number;
|
||||
usageMetadata?: GenerateContentResponseUsageMetadata;
|
||||
} | null = null;
|
||||
private activeRecordId: string | null = null;
|
||||
private activeRecordTimestamp: string | null = null;
|
||||
|
|
@ -39,9 +425,37 @@ class ExportSessionContext implements SessionContext {
|
|||
case 'user_message_chunk':
|
||||
this.handleMessageChunk('user', update.content);
|
||||
break;
|
||||
case 'agent_message_chunk':
|
||||
this.handleMessageChunk('assistant', update.content);
|
||||
case 'agent_message_chunk': {
|
||||
// Extract usageMetadata from _meta if available
|
||||
const usageMeta = update._meta as
|
||||
| {
|
||||
usage?: {
|
||||
inputTokens?: number;
|
||||
outputTokens?: number;
|
||||
totalTokens?: number;
|
||||
thoughtTokens?: number;
|
||||
cachedReadTokens?: number;
|
||||
};
|
||||
}
|
||||
| undefined;
|
||||
const usageMetadata: GenerateContentResponseUsageMetadata | undefined =
|
||||
usageMeta?.usage
|
||||
? {
|
||||
promptTokenCount: usageMeta.usage.inputTokens,
|
||||
candidatesTokenCount: usageMeta.usage.outputTokens,
|
||||
totalTokenCount: usageMeta.usage.totalTokens,
|
||||
thoughtsTokenCount: usageMeta.usage.thoughtTokens,
|
||||
cachedContentTokenCount: usageMeta.usage.cachedReadTokens,
|
||||
}
|
||||
: undefined;
|
||||
this.handleMessageChunk(
|
||||
'assistant',
|
||||
update.content,
|
||||
'assistant',
|
||||
usageMetadata,
|
||||
);
|
||||
break;
|
||||
}
|
||||
case 'agent_thought_chunk':
|
||||
this.handleMessageChunk('assistant', update.content, 'thinking');
|
||||
break;
|
||||
|
|
@ -79,6 +493,7 @@ class ExportSessionContext implements SessionContext {
|
|||
role: 'user' | 'assistant',
|
||||
content: { type: string; text?: string },
|
||||
messageRole: 'user' | 'assistant' | 'thinking' = role,
|
||||
usageMetadata?: GenerateContentResponseUsageMetadata,
|
||||
): void {
|
||||
if (content.type !== 'text' || !content.text) return;
|
||||
|
||||
|
|
@ -98,12 +513,17 @@ class ExportSessionContext implements SessionContext {
|
|||
this.currentMessage.role === messageRole
|
||||
) {
|
||||
this.currentMessage.parts.push({ text: content.text });
|
||||
// Merge usageMetadata if provided (for assistant messages)
|
||||
if (usageMetadata && role === 'assistant') {
|
||||
this.currentMessage.usageMetadata = usageMetadata;
|
||||
}
|
||||
} else {
|
||||
this.currentMessage = {
|
||||
type: role,
|
||||
role: messageRole,
|
||||
parts: [{ text: content.text }],
|
||||
timestamp: Date.now(),
|
||||
...(usageMetadata && role === 'assistant' ? { usageMetadata } : {}),
|
||||
};
|
||||
}
|
||||
}
|
||||
|
|
@ -205,7 +625,7 @@ class ExportSessionContext implements SessionContext {
|
|||
if (!this.currentMessage) return;
|
||||
|
||||
const uuid = this.getMessageUuid();
|
||||
this.messages.push({
|
||||
const exportMessage: ExportMessage = {
|
||||
uuid,
|
||||
sessionId: this.sessionId,
|
||||
timestamp: this.getMessageTimestamp(),
|
||||
|
|
@ -214,7 +634,17 @@ class ExportSessionContext implements SessionContext {
|
|||
role: this.currentMessage.role,
|
||||
parts: this.currentMessage.parts,
|
||||
},
|
||||
});
|
||||
};
|
||||
|
||||
// Add usageMetadata for assistant messages
|
||||
if (
|
||||
this.currentMessage.type === 'assistant' &&
|
||||
this.currentMessage.usageMetadata
|
||||
) {
|
||||
exportMessage.usageMetadata = this.currentMessage.usageMetadata;
|
||||
}
|
||||
|
||||
this.messages.push(exportMessage);
|
||||
|
||||
this.currentMessage = null;
|
||||
}
|
||||
|
|
@ -258,9 +688,13 @@ export async function collectSessionData(
|
|||
// Get the export messages
|
||||
const messages = exportContext.getMessages();
|
||||
|
||||
// Extract metadata from conversation
|
||||
const metadata = await extractMetadata(conversation, config);
|
||||
|
||||
return {
|
||||
sessionId: conversation.sessionId,
|
||||
startTime: conversation.startTime,
|
||||
messages,
|
||||
metadata,
|
||||
};
|
||||
}
|
||||
|
|
|
|||
|
|
@ -36,6 +36,7 @@ export function injectDataIntoHtmlTemplate(
|
|||
sessionId: string;
|
||||
startTime: string;
|
||||
messages: unknown[];
|
||||
metadata?: unknown;
|
||||
},
|
||||
): string {
|
||||
const jsonData = JSON.stringify(data, null, 2);
|
||||
|
|
|
|||
|
|
@ -12,15 +12,60 @@ import type { ExportSessionData } from '../types.js';
|
|||
*/
|
||||
export function toJsonl(sessionData: ExportSessionData): string {
|
||||
const lines: string[] = [];
|
||||
const sourceMetadata = sessionData.metadata;
|
||||
|
||||
// Add session metadata as the first line
|
||||
lines.push(
|
||||
JSON.stringify({
|
||||
type: 'session_metadata',
|
||||
sessionId: sessionData.sessionId,
|
||||
startTime: sessionData.startTime,
|
||||
}),
|
||||
);
|
||||
const metadata: Record<string, unknown> = {
|
||||
type: 'session_metadata',
|
||||
sessionId: sessionData.sessionId,
|
||||
startTime: sessionData.startTime,
|
||||
};
|
||||
|
||||
// Add all metadata fields if available
|
||||
if (sourceMetadata?.exportTime) {
|
||||
metadata['exportTime'] = sourceMetadata.exportTime;
|
||||
}
|
||||
if (sourceMetadata?.cwd) {
|
||||
metadata['cwd'] = sourceMetadata.cwd;
|
||||
}
|
||||
if (sourceMetadata?.gitRepo) {
|
||||
metadata['gitRepo'] = sourceMetadata.gitRepo;
|
||||
}
|
||||
if (sourceMetadata?.gitBranch) {
|
||||
metadata['gitBranch'] = sourceMetadata.gitBranch;
|
||||
}
|
||||
if (sourceMetadata?.model) {
|
||||
metadata['model'] = sourceMetadata.model;
|
||||
}
|
||||
if (sourceMetadata?.channel) {
|
||||
metadata['channel'] = sourceMetadata.channel;
|
||||
}
|
||||
if (sourceMetadata?.promptCount !== undefined) {
|
||||
metadata['promptCount'] = sourceMetadata.promptCount;
|
||||
}
|
||||
if (sourceMetadata?.contextUsagePercent !== undefined) {
|
||||
metadata['contextUsagePercent'] = sourceMetadata.contextUsagePercent;
|
||||
}
|
||||
if (sourceMetadata?.contextWindowSize !== undefined) {
|
||||
metadata['contextWindowSize'] = sourceMetadata.contextWindowSize;
|
||||
}
|
||||
if (sourceMetadata?.totalTokens !== undefined) {
|
||||
metadata['totalTokens'] = sourceMetadata.totalTokens;
|
||||
}
|
||||
if (sourceMetadata?.filesWritten !== undefined) {
|
||||
metadata['filesWritten'] = sourceMetadata.filesWritten;
|
||||
}
|
||||
if (sourceMetadata?.linesAdded !== undefined) {
|
||||
metadata['linesAdded'] = sourceMetadata.linesAdded;
|
||||
}
|
||||
if (sourceMetadata?.linesRemoved !== undefined) {
|
||||
metadata['linesRemoved'] = sourceMetadata.linesRemoved;
|
||||
}
|
||||
if (sourceMetadata?.uniqueFiles && sourceMetadata.uniqueFiles.length > 0) {
|
||||
metadata['uniqueFiles'] = sourceMetadata.uniqueFiles;
|
||||
}
|
||||
|
||||
lines.push(JSON.stringify(metadata));
|
||||
|
||||
// Add each message as a separate line
|
||||
for (const message of sessionData.messages) {
|
||||
|
|
|
|||
|
|
@ -11,12 +11,82 @@ import type { ExportSessionData, ExportMessage } from '../types.js';
|
|||
*/
|
||||
export function toMarkdown(sessionData: ExportSessionData): string {
|
||||
const lines: string[] = [];
|
||||
const metadata = sessionData.metadata;
|
||||
|
||||
// Add header with metadata
|
||||
lines.push('# Chat Session Export\n');
|
||||
lines.push(`- **Session ID**: \`${sanitizeText(sessionData.sessionId)}\``);
|
||||
lines.push(`- **Start Time**: ${sanitizeText(sessionData.startTime)}`);
|
||||
lines.push(`- **Exported**: ${new Date().toISOString()}`);
|
||||
lines.push(
|
||||
`- **Exported**: ${sanitizeText(metadata?.exportTime ?? new Date().toISOString())}`,
|
||||
);
|
||||
|
||||
lines.push('');
|
||||
|
||||
// Add context info
|
||||
if (metadata?.cwd) {
|
||||
lines.push(`- **Working Directory**: \`${sanitizeText(metadata.cwd)}\``);
|
||||
}
|
||||
if (metadata?.gitRepo) {
|
||||
lines.push(`- **Git Repository**: ${sanitizeText(metadata.gitRepo)}`);
|
||||
}
|
||||
if (metadata?.gitBranch) {
|
||||
lines.push(`- **Git Branch**: \`${sanitizeText(metadata.gitBranch)}\``);
|
||||
}
|
||||
|
||||
lines.push('');
|
||||
|
||||
// Add model info
|
||||
if (metadata?.model) {
|
||||
lines.push(`- **Model**: ${sanitizeText(metadata.model)}`);
|
||||
}
|
||||
if (metadata?.channel) {
|
||||
lines.push(`- **Channel**: ${sanitizeText(metadata.channel)}`);
|
||||
}
|
||||
if (metadata?.promptCount !== undefined) {
|
||||
lines.push(`- **Prompt Count**: ${metadata.promptCount}`);
|
||||
}
|
||||
|
||||
lines.push('');
|
||||
|
||||
// Add token stats
|
||||
if (metadata?.totalTokens !== undefined) {
|
||||
lines.push(`- **Total Tokens**: ${metadata.totalTokens}`);
|
||||
}
|
||||
if (metadata?.contextWindowSize !== undefined) {
|
||||
lines.push(`- **Context Window Size**: ${metadata.contextWindowSize}`);
|
||||
}
|
||||
if (metadata?.contextUsagePercent !== undefined) {
|
||||
lines.push(`- **Context Usage**: ${metadata.contextUsagePercent}%`);
|
||||
}
|
||||
|
||||
lines.push('');
|
||||
|
||||
// Add file operation stats
|
||||
if (metadata?.filesWritten !== undefined) {
|
||||
lines.push(`- **Files Written**: ${metadata.filesWritten}`);
|
||||
}
|
||||
if (metadata?.linesAdded !== undefined) {
|
||||
lines.push(`- **Lines Added**: ${metadata.linesAdded}`);
|
||||
}
|
||||
if (metadata?.linesRemoved !== undefined) {
|
||||
lines.push(`- **Lines Removed**: ${metadata.linesRemoved}`);
|
||||
}
|
||||
|
||||
// Add unique files list if available
|
||||
if (metadata?.uniqueFiles && metadata.uniqueFiles.length > 0) {
|
||||
lines.push('');
|
||||
lines.push('<details>');
|
||||
lines.push(
|
||||
`<summary><strong>Unique Files Referenced (${metadata.uniqueFiles.length})</strong></summary>`,
|
||||
);
|
||||
lines.push('');
|
||||
for (const file of metadata.uniqueFiles) {
|
||||
lines.push(`- \`${sanitizeText(file)}\``);
|
||||
}
|
||||
lines.push('</details>');
|
||||
}
|
||||
|
||||
lines.push('\n---\n');
|
||||
|
||||
// Process each message
|
||||
|
|
|
|||
|
|
@ -28,6 +28,14 @@ export function normalizeSessionData(
|
|||
}
|
||||
});
|
||||
|
||||
// Build index of assistant messages by uuid for usageMetadata merging
|
||||
const assistantMessageIndexByUuid = new Map<string, number>();
|
||||
normalized.forEach((message, index) => {
|
||||
if (message.type === 'assistant') {
|
||||
assistantMessageIndexByUuid.set(message.uuid, index);
|
||||
}
|
||||
});
|
||||
|
||||
// Merge tool result information into tool call messages
|
||||
for (const record of originalRecords) {
|
||||
if (record.type !== 'tool_result') continue;
|
||||
|
|
@ -58,6 +66,20 @@ export function normalizeSessionData(
|
|||
mergeToolCallData(existingMessage.toolCall, toolCallMessage.toolCall);
|
||||
}
|
||||
|
||||
// Merge usageMetadata from assistant records
|
||||
for (const record of originalRecords) {
|
||||
if (record.type !== 'assistant') continue;
|
||||
if (!record.usageMetadata) continue;
|
||||
|
||||
const existingIndex = assistantMessageIndexByUuid.get(record.uuid);
|
||||
if (existingIndex !== undefined) {
|
||||
// Only set if not already present from collect phase
|
||||
if (!normalized[existingIndex].usageMetadata) {
|
||||
normalized[existingIndex].usageMetadata = record.usageMetadata;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
...sessionData,
|
||||
messages: normalized,
|
||||
|
|
|
|||
|
|
@ -4,6 +4,8 @@
|
|||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
import type { GenerateContentResponseUsageMetadata } from '@google/genai';
|
||||
|
||||
/**
|
||||
* Universal export message format - SSOT for all export formats.
|
||||
* This is format-agnostic and contains all information needed for any export type.
|
||||
|
|
@ -25,6 +27,9 @@ export interface ExportMessage {
|
|||
/** Model used for assistant messages */
|
||||
model?: string;
|
||||
|
||||
/** Token usage for this message (mainly for assistant messages) */
|
||||
usageMetadata?: GenerateContentResponseUsageMetadata;
|
||||
|
||||
/** For tool_call messages */
|
||||
toolCall?: {
|
||||
toolCallId: string;
|
||||
|
|
@ -44,6 +49,44 @@ export interface ExportMessage {
|
|||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Metadata for export session - contains aggregated statistics and session context.
|
||||
*/
|
||||
export interface ExportMetadata {
|
||||
/** Session ID */
|
||||
sessionId: string;
|
||||
/** ISO timestamp when session started */
|
||||
startTime: string;
|
||||
/** Export timestamp */
|
||||
exportTime: string;
|
||||
/** Current working directory */
|
||||
cwd: string;
|
||||
/** Git repository name, if available */
|
||||
gitRepo?: string;
|
||||
/** Git branch name, if available */
|
||||
gitBranch?: string;
|
||||
/** Model used in the session */
|
||||
model?: string;
|
||||
/** Channel/source identifier */
|
||||
channel?: string;
|
||||
/** Number of user prompts in the session */
|
||||
promptCount: number;
|
||||
/** Context window utilization percentage (0-100) */
|
||||
contextUsagePercent?: number;
|
||||
/** Context window size in tokens (used for calculating percentage) */
|
||||
contextWindowSize?: number;
|
||||
/** Total tokens used (prompt + completion) */
|
||||
totalTokens?: number;
|
||||
/** Number of files written/edited */
|
||||
filesWritten?: number;
|
||||
/** Lines of code added */
|
||||
linesAdded?: number;
|
||||
/** Lines of code removed */
|
||||
linesRemoved?: number;
|
||||
/** Unique files referenced in the session (written files only) */
|
||||
uniqueFiles: string[];
|
||||
}
|
||||
|
||||
/**
|
||||
* Complete export session data - the single source of truth.
|
||||
*/
|
||||
|
|
@ -51,4 +94,6 @@ export interface ExportSessionData {
|
|||
sessionId: string;
|
||||
startTime: string;
|
||||
messages: ExportMessage[];
|
||||
/** Session metadata and statistics */
|
||||
metadata?: ExportMetadata;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue