@renxqoo/renx-code 0.0.9 → 0.0.10

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

@@ -1,372 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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'
-    );
-  });
-});