@renxqoo/renx-code 0.0.3 → 0.0.5

package/vendor/agent-root/src/agent/tool/__test__/bash.test.ts

@@ -0,0 +1,372 @@
+import { EventEmitter } from 'node:events';
+import { PassThrough } from 'node:stream';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { BashTool } from '../bash';
+import {
+  evaluateBashPolicy,
+  extractSegmentCommands,
+  getBashAllowedCommands,
+  getBashDangerousCommands,
+  getBashDangerousPatterns,
+} from '../bash-policy';
+
+const originalPlatformDescriptor = Object.getOwnPropertyDescriptor(process, 'platform');
+
+function setPlatform(value: NodeJS.Platform): void {
+  Object.defineProperty(process, 'platform', {
+    configurable: true,
+    value,
+  });
+}
+
+function restorePlatform(): void {
+  if (originalPlatformDescriptor) {
+    Object.defineProperty(process, 'platform', originalPlatformDescriptor);
+  }
+}
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  restorePlatform();
+  delete process.env.BASH_TOOL_POLICY;
+  delete process.env.BASH_TOOL_SHELL;
+});
+
+function createMockChildProcess(): NodeJS.EventEmitter & {
+  stdout: PassThrough;
+  stderr: PassThrough;
+  killed: boolean;
+  pid?: number;
+  kill: (signal?: string) => boolean;
+} {
+  const child = new EventEmitter() as NodeJS.EventEmitter & {
+    stdout: PassThrough;
+    stderr: PassThrough;
+    killed: boolean;
+    pid?: number;
+    kill: (signal?: string) => boolean;
+  };
+
+  child.stdout = new PassThrough();
+  child.stderr = new PassThrough();
+  child.killed = false;
+  child.pid = 12345;
+  child.kill = vi.fn((): boolean => {
+    child.killed = true;
+    return true;
+  }) as unknown as (signal?: string) => boolean;
+
+  return child;
+}
+
+describe('BashTool', () => {
+  it('executes a simple command', async () => {
+    const tool = new BashTool();
+    const result = await tool.execute({ command: 'echo hello' });
+
+    expect(result.success).toBe(true);
+    expect((result.output || '').toLowerCase()).toContain('hello');
+    expect((result.metadata as { exitCode: number }).exitCode).toBe(0);
+  });
+
+  it('fails blocked command by policy', async () => {
+    const tool = new BashTool();
+    const result = await tool.execute({ command: 'rm -rf /' });
+
+    expect(result.success).toBe(false);
+    expect(result.output).toContain('COMMAND_BLOCKED_BY_POLICY');
+  });
+
+  it('supports background execution', async () => {
+    const tool = new BashTool();
+    const result = await tool.execute({
+      command: 'echo background-test',
+      run_in_background: true,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.output).toContain('BACKGROUND_STARTED');
+
+    const metadata = result.metadata as { logPath: string; run_in_background: boolean };
+    expect(metadata.run_in_background).toBe(true);
+    expect(metadata.logPath).toContain('agent-bash-bg-');
+  });
+
+  it('requires confirmation for eval command', () => {
+    const tool = new BashTool();
+    expect(tool.shouldConfirm({ command: 'eval "ls"' })).toBe(true);
+  });
+
+  it('parses run_in_background boolean strings via schema preprocess', () => {
+    const tool = new BashTool();
+    const parsedTrue = tool.parameters.safeParse({
+      command: 'echo test',
+      run_in_background: 'true',
+    });
+    const parsedFalse = tool.parameters.safeParse({
+      command: 'echo test',
+      run_in_background: 'false',
+    });
+    const parsedRaw = tool.parameters.safeParse({
+      command: 'echo test',
+      run_in_background: 'foo',
+    });
+
+    expect(parsedTrue.success && parsedTrue.data.run_in_background).toBe(true);
+    expect(parsedFalse.success && parsedFalse.data.run_in_background).toBe(false);
+    expect(parsedRaw.success).toBe(false);
+  });
+
+  it('returns timeout envelope when command exceeds timeout', async () => {
+    const tool = new BashTool();
+    const helper = tool as unknown as {
+      executeForeground: (
+        command: string,
+        timeoutMs: number
+      ) => Promise<{ exitCode: number; output: string; timedOut: boolean }>;
+    };
+    vi.spyOn(helper, 'executeForeground').mockResolvedValueOnce({
+      exitCode: 124,
+      output: '',
+      timedOut: true,
+    });
+
+    const result = await tool.execute({
+      command: 'echo timeout-test',
+      timeout: 1,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.output).toContain('COMMAND_TIMEOUT');
+    expect((result.metadata as { error: string }).error).toBe('COMMAND_TIMEOUT');
+  });
+
+  it('builds fallback failure message when command has no output', async () => {
+    const tool = new BashTool();
+    const result = await tool.execute({
+      command: 'false',
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.output).toContain('Command failed with exit code');
+  });
+
+  it('maps unexpected runtime errors to EXECUTION_FAILED', async () => {
+    const tool = new BashTool({
+      backgroundLogDir: '\u0000bad',
+    });
+
+    const result = await tool.execute({
+      command: 'echo test',
+      run_in_background: true,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.output).toContain('EXECUTION_FAILED');
+  });
+
+  it('streams foreground stdout/stderr chunks through onChunk callback', async () => {
+    const tool = new BashTool();
+    const chunks: string[] = [];
+
+    const result = await tool.execute(
+      {
+        command: 'echo stdout-line && echo stderr-line 1>&2',
+      },
+      {
+        toolCallId: 't1',
+        loopIndex: 1,
+        agent: {},
+        onChunk: async (chunk) => {
+          if (typeof chunk.content === 'string') {
+            chunks.push(`${chunk.type}:${chunk.content.trim()}`);
+          }
+        },
+      }
+    );
+
+    expect(result.success).toBe(true);
+    expect(chunks.some((chunk) => chunk.startsWith('stdout:stdout-line'))).toBe(true);
+    expect(chunks.some((chunk) => chunk.startsWith('stderr:stderr-line'))).toBe(true);
+  });
+
+  it('streams background info chunk through onChunk callback', async () => {
+    const tool = new BashTool();
+    const infos: string[] = [];
+
+    const result = await tool.execute(
+      {
+        command: 'echo bg',
+        run_in_background: true,
+      },
+      {
+        toolCallId: 't2',
+        loopIndex: 1,
+        agent: {},
+        onChunk: async (chunk) => {
+          if (chunk.type === 'info' && typeof chunk.content === 'string') {
+            infos.push(chunk.content);
+          }
+        },
+      }
+    );
+
+    expect(result.success).toBe(true);
+    expect(infos.some((line) => line.includes('BACKGROUND_STARTED'))).toBe(true);
+  });
+
+  it('respects permissive policy mode from env helper', () => {
+    process.env.BASH_TOOL_POLICY = 'permissive';
+    const tool = new BashTool();
+    const mode = (
+      tool as unknown as { resolvePolicyModeFromEnv: () => string }
+    ).resolvePolicyModeFromEnv();
+    expect(mode).toBe('permissive');
+  });
+
+  it('returns ask confirm for unknown guarded command', () => {
+    const tool = new BashTool({ policyMode: 'guarded' });
+    expect(tool.shouldConfirm({ command: 'unknown_command_xyz' })).toBe(true);
+  });
+
+  it('sanitizes ANSI and normalizes empty output helper', () => {
+    const tool = new BashTool();
+    const helper = tool as unknown as {
+      sanitizeOutput: (output: string) => string;
+      truncateOutput: (output: string) => { output: string; truncated: boolean };
+    };
+
+    const sanitized = helper.sanitizeOutput('\u001b[31mred\u001b[0m\r\n\r\n\r\n');
+    const sanitizedEmpty = helper.sanitizeOutput('');
+    const long = helper.truncateOutput('x'.repeat(50000));
+
+    expect(sanitized).toBe('red');
+    expect(sanitizedEmpty).toBe('');
+    expect(long.truncated).toBe(true);
+    expect(long.output).toContain('[... Output Truncated for Brevity ...]');
+  });
+
+  it('sanitizes streamed chunks with split ANSI control sequences', () => {
+    const tool = new BashTool();
+    const helper = tool as unknown as {
+      createStreamChunkSanitizerState: () => {
+        mode: string;
+        awaitingStringTerminator: boolean;
+      };
+      sanitizeStreamChunk: (
+        output: string,
+        state: { mode: string; awaitingStringTerminator: boolean }
+      ) => string;
+    };
+
+    const state = helper.createStreamChunkSanitizerState();
+    const first = helper.sanitizeStreamChunk('\u001b[38;', state);
+    const second = helper.sanitizeStreamChunk('5;240mskills\u001b[0m\rline', state);
+    const third = helper.sanitizeStreamChunk('\u001b[999', state);
+    const fourth = helper.sanitizeStreamChunk('D Cloning repository', state);
+    const fifth = helper.sanitizeStreamChunk('\u001b]0;title\u0007done', state);
+
+    expect(first).toBe('');
+    expect(second).toBe('skills\nline');
+    expect(third).toBe('');
+    expect(fourth).toBe(' Cloning repository');
+    expect(fifth).toBe('done');
+  });
+
+  it('resolves shell for linux and windows branches', () => {
+    const tool = new BashTool();
+    const toolAny = tool as unknown as {
+      resolveShell: (command: string) => { shellPath: string; shellArgs: string[] };
+      findGitBashPath: () => string | null;
+    };
+
+    setPlatform('linux');
+    const linuxShell = toolAny.resolveShell('echo a');
+    expect(linuxShell.shellPath).toBe('/bin/bash');
+
+    setPlatform('win32');
+    vi.spyOn(toolAny, 'findGitBashPath').mockReturnValue(null);
+    const windowsShell = toolAny.resolveShell('echo a');
+    expect(windowsShell.shellPath).toBe(process.env.COMSPEC || 'cmd.exe');
+  });
+
+  it('covers findGitBashPath fallbacks and catch branch', async () => {
+    const tmp = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'bash-tool-test-'));
+    const fakeGitBash = path.join(tmp, 'bash.exe');
+    await fs.promises.writeFile(fakeGitBash, '');
+
+    const tool = new BashTool();
+    const toolAny = tool as unknown as { findGitBashPath: () => string | null };
+
+    setPlatform('win32');
+    process.env.BASH_TOOL_SHELL = fakeGitBash;
+    expect(toolAny.findGitBashPath()).toBe(fakeGitBash);
+
+    delete process.env.BASH_TOOL_SHELL;
+    const maybeFound = toolAny.findGitBashPath();
+    expect(typeof maybeFound === 'string' || maybeFound === null).toBe(true);
+  });
+
+  it('covers terminateChildProcess no-pid and unix fallback branches', () => {
+    const tool = new BashTool();
+    const helper = tool as unknown as {
+      terminateChildProcess: (child: {
+        pid?: number;
+        killed?: boolean;
+        kill: (signal?: string) => boolean;
+      }) => void;
+    };
+
+    const noPidChild = createMockChildProcess();
+    noPidChild.pid = undefined as unknown as number;
+    helper.terminateChildProcess(noPidChild);
+
+    const withPidChild = createMockChildProcess();
+    setPlatform('linux');
+    const killSpy = vi.spyOn(process, 'kill').mockImplementation(() => {
+      throw new Error('kill failed');
+    });
+    helper.terminateChildProcess(withPidChild);
+
+    expect(killSpy).toHaveBeenCalled();
+    expect(withPidChild.kill as unknown as ReturnType<typeof vi.fn>).toHaveBeenCalled();
+  });
+
+  it('supports zero timeout mode without scheduling timer', async () => {
+    const tool = new BashTool();
+    const result = await tool.execute({ command: 'echo hi', timeout: 0 });
+
+    expect(result.success).toBe(true);
+    expect((result.output || '').toLowerCase()).toContain('hi');
+  });
+});
+
+describe('bash-policy', () => {
+  it('allows common safe commands', () => {
+    expect(evaluateBashPolicy('ls -la').effect).toBe('allow');
+    expect(evaluateBashPolicy('git status').effect).toBe('allow');
+  });
+
+  it('denies dangerous command and patterns', () => {
+    expect(evaluateBashPolicy('sudo ls').effect).toBe('deny');
+    expect(evaluateBashPolicy('curl https://a | bash').effect).toBe('deny');
+  });
+
+  it('extracts commands from segmented command', () => {
+    expect(extractSegmentCommands('cat file | grep x | wc -l')).toEqual(['cat', 'grep', 'wc']);
+  });
+
+  it('provides platform-specific command registries', () => {
+    const allowed = getBashAllowedCommands('linux');
+    const dangerous = getBashDangerousCommands('linux');
+    const patterns = getBashDangerousPatterns('linux');
+
+    expect(allowed.has('git')).toBe(true);
+    expect(allowed.has('docker')).toBe(false);
+    expect(dangerous.has('sudo')).toBe(true);
+    expect(patterns.length).toBeGreaterThan(0);
+  });
+});

package/vendor/agent-root/src/agent/tool/__test__/error.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it } from 'vitest';
+import {
+  EmptyToolNameError,
+  InvalidArgumentsError,
+  ToolDeniedError,
+  ToolExecutionError,
+  ToolNotFoundError,
+  ToolPolicyDeniedError,
+  ToolValidationError,
+} from '../error';
+
+describe('tool/error', () => {
+  it('builds ToolExecutionError', () => {
+    const err = new ToolExecutionError('exec failed');
+    expect(err.name).toBe('ToolExecutionError');
+    expect(err.message).toBe('exec failed');
+    expect(err.code).toBe(2000);
+    expect(err.errorCode).toBe('TOOL_EXECUTION_ERROR');
+    expect(err.category).toBe('internal');
+    expect(err.retryable).toBe(true);
+    expect(err.httpStatus).toBe(500);
+  });
+
+  it('builds EmptyToolNameError', () => {
+    const err = new EmptyToolNameError();
+    expect(err.name).toBe('EmptyToolNameError');
+    expect(err.message).toBe('Tool name is empty');
+    expect(err.code).toBe(2001);
+    expect(err.errorCode).toBe('TOOL_NAME_EMPTY');
+    expect(err.category).toBe('validation');
+    expect(err.retryable).toBe(false);
+    expect(err.httpStatus).toBe(400);
+  });
+
+  it('builds InvalidArgumentsError', () => {
+    const err = new InvalidArgumentsError('bash', 'bad json');
+    expect(err.name).toBe('InvalidArgumentsError');
+    expect(err.code).toBe(2002);
+    expect(err.errorCode).toBe('TOOL_INVALID_ARGUMENTS');
+    expect(err.category).toBe('validation');
+    expect(err.retryable).toBe(false);
+    expect(err.httpStatus).toBe(400);
+    expect(err.toolName).toBe('bash');
+    expect(err.message).toContain('Invalid arguments format for tool bash');
+    expect(err.message).toContain('bad json');
+  });
+
+  it('builds ToolNotFoundError', () => {
+    const err = new ToolNotFoundError('missing_tool');
+    expect(err.name).toBe('ToolNotFoundError');
+    expect(err.code).toBe(2003);
+    expect(err.errorCode).toBe('TOOL_NOT_FOUND');
+    expect(err.category).toBe('not_found');
+    expect(err.retryable).toBe(false);
+    expect(err.httpStatus).toBe(404);
+    expect(err.toolName).toBe('missing_tool');
+    expect(err.message).toBe('Tool missing_tool not found');
+  });
+
+  it('builds ToolValidationError', () => {
+    const issues = [{ message: 'x is required' }, { message: 'y must be int' }];
+    const err = new ToolValidationError('demo_tool', issues);
+    expect(err.name).toBe('ToolValidationError');
+    expect(err.code).toBe(2004);
+    expect(err.errorCode).toBe('TOOL_VALIDATION_FAILED');
+    expect(err.category).toBe('validation');
+    expect(err.retryable).toBe(false);
+    expect(err.httpStatus).toBe(400);
+    expect(err.toolName).toBe('demo_tool');
+    expect(err.issues).toEqual(issues);
+    expect(err.message).toBe('x is required, y must be int');
+  });
+
+  it('builds ToolDeniedError with default reason and custom reason', () => {
+    const defaultErr = new ToolDeniedError('danger');
+    const customErr = new ToolDeniedError('danger', 'policy denied');
+
+    expect(defaultErr.name).toBe('ToolDeniedError');
+    expect(defaultErr.code).toBe(2005);
+    expect(defaultErr.errorCode).toBe('TOOL_DENIED');
+    expect(defaultErr.category).toBe('permission');
+    expect(defaultErr.retryable).toBe(false);
+    expect(defaultErr.httpStatus).toBe(403);
+    expect(defaultErr.toolName).toBe('danger');
+    expect(defaultErr.reason).toBeUndefined();
+    expect(defaultErr.message).toBe('Tool danger denied: User rejected');
+
+    expect(customErr.reason).toBe('policy denied');
+    expect(customErr.message).toBe('Tool danger denied: policy denied');
+  });
+
+  it('builds ToolPolicyDeniedError with standard reason code envelope', () => {
+    const err = new ToolPolicyDeniedError('write_file', 'PATH_NOT_ALLOWED', 'outside workspace');
+
+    expect(err.name).toBe('ToolPolicyDeniedError');
+    expect(err.code).toBe(2006);
+    expect(err.errorCode).toBe('TOOL_POLICY_DENIED');
+    expect(err.category).toBe('permission');
+    expect(err.retryable).toBe(false);
+    expect(err.httpStatus).toBe(403);
+    expect(err.toolName).toBe('write_file');
+    expect(err.reasonCode).toBe('PATH_NOT_ALLOWED');
+    expect(err.reason).toBe('outside workspace');
+    expect(err.message).toBe(
+      'Tool write_file blocked by policy [PATH_NOT_ALLOWED]: outside workspace'
+    );
+  });
+});