@renxqoo/renx-code 0.0.3 → 0.0.5

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

@@ -0,0 +1,368 @@
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { afterEach, describe, expect, it } from 'vitest';
+import { WriteFileTool } from '../write-file';
+import { appendContent, appendRawArgs, createWriteBufferSession } from '../../agent/write-buffer';
+
+const tempDirs: string[] = [];
+
+async function createTempDir(): Promise<string> {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'renx-write-file-tool-'));
+  tempDirs.push(dir);
+  return dir;
+}
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => fs.rm(dir, { recursive: true, force: true })));
+});
+
+function parseOutput<T>(output: string | undefined): T {
+  return JSON.parse(output || '{}') as T;
+}
+
+describe('WriteFileTool', () => {
+  it('writes small content directly with OK response', async () => {
+    const allowedDir = await createTempDir();
+    const bufferDir = await createTempDir();
+    const tool = new WriteFileTool({
+      allowedDirectories: [allowedDir],
+      bufferBaseDir: bufferDir,
+      maxChunkBytes: 64,
+    });
+    const target = path.join(allowedDir, 'a.txt');
+
+    const result = await tool.execute({
+      path: target,
+      content: 'hello',
+      mode: 'direct',
+    });
+
+    expect(result.success).toBe(true);
+    const payload = parseOutput<{
+      ok: boolean;
+      code: string;
+      message: string;
+      nextAction: string;
+    }>(result.output);
+    expect(payload).toMatchObject({
+      ok: true,
+      code: 'OK',
+      nextAction: 'none',
+    });
+    expect(payload.message).toContain('File written successfully');
+    expect(await fs.readFile(target, 'utf8')).toBe('hello');
+  });
+
+  it('allows write when target path goes through a symlinked directory inside allowed roots', async () => {
+    const allowedDir = await createTempDir();
+    const linkBaseDir = await createTempDir();
+    const bufferDir = await createTempDir();
+    const linkDir = path.join(linkBaseDir, 'allowed-link');
+    await fs.symlink(allowedDir, linkDir);
+
+    const tool = new WriteFileTool({
+      allowedDirectories: [allowedDir],
+      bufferBaseDir: bufferDir,
+      maxChunkBytes: 64,
+    });
+
+    const targetViaLink = path.join(linkDir, 'through-link.txt');
+    const result = await tool.execute({
+      path: targetViaLink,
+      content: 'hello-link',
+      mode: 'direct',
+    });
+
+    expect(result.success).toBe(true);
+    expect(await fs.readFile(path.join(allowedDir, 'through-link.txt'), 'utf8')).toBe('hello-link');
+  });
+
+  it('buffers large direct write and requests finalize', async () => {
+    const allowedDir = await createTempDir();
+    const bufferDir = await createTempDir();
+    const tool = new WriteFileTool({
+      allowedDirectories: [allowedDir],
+      bufferBaseDir: bufferDir,
+      maxChunkBytes: 8,
+    });
+    const target = path.join(allowedDir, 'large.txt');
+
+    const result = await tool.execute(
+      {
+        path: target,
+        content: '0123456789012345',
+        mode: 'direct',
+      },
+      {
+        toolCallId: 'write_call_1',
+        loopIndex: 1,
+        agent: {},
+      }
+    );
+
+    expect(result.success).toBe(false);
+    const payload = parseOutput<{
+      ok: boolean;
+      code: string;
+      nextAction: string;
+      buffer: { bufferId: string; bufferedBytes: number; maxChunkBytes: number };
+    }>(result.output);
+    expect(payload.ok).toBe(false);
+    expect(payload.code).toBe('WRITE_FILE_PARTIAL_BUFFERED');
+    expect(payload.nextAction).toBe('finalize');
+    expect(payload.buffer.bufferId).toBe('write_call_1');
+    expect(payload.buffer.bufferedBytes).toBe(Buffer.byteLength('0123456789012345', 'utf8'));
+    expect(payload.buffer.maxChunkBytes).toBe(8);
+  });
+
+  it('finalizes a fully buffered direct write without any intermediate chunk step', async () => {
+    const allowedDir = await createTempDir();
+    const bufferDir = await createTempDir();
+    const tool = new WriteFileTool({
+      allowedDirectories: [allowedDir],
+      bufferBaseDir: bufferDir,
+      maxChunkBytes: 8,
+    });
+    const target = path.join(allowedDir, 'finalize.txt');
+    const fullContent = 'abcdefghi';
+
+    const direct = await tool.execute(
+      {
+        path: target,
+        content: 'abcdefghi',
+        mode: 'direct',
+      },
+      {
+        toolCallId: 'write_call_2',
+        loopIndex: 1,
+        agent: {},
+      }
+    );
+    const directPayload = parseOutput<{ buffer: { bufferId: string } }>(direct.output);
+
+    const finalize = await tool.execute({
+      path: target,
+      mode: 'finalize',
+      bufferId: directPayload.buffer.bufferId,
+    });
+    const finalizePayload = parseOutput<{ ok: boolean; code: string; nextAction: string }>(
+      finalize.output
+    );
+    expect(finalizePayload).toMatchObject({
+      ok: true,
+      code: 'WRITE_FILE_FINALIZE_OK',
+      nextAction: 'none',
+    });
+    expect(await fs.readFile(target, 'utf8')).toBe(fullContent);
+  });
+
+  it('finalizes buffered content to the original full direct payload', async () => {
+    const allowedDir = await createTempDir();
+    const bufferDir = await createTempDir();
+    const tool = new WriteFileTool({
+      allowedDirectories: [allowedDir],
+      bufferBaseDir: bufferDir,
+      maxChunkBytes: 8,
+    });
+    const target = path.join(allowedDir, 'finalize-no-checksum.txt');
+    const content = 'abcdefghijk';
+
+    const direct = await tool.execute(
+      {
+        path: target,
+        content,
+        mode: 'direct',
+      },
+      {
+        toolCallId: 'write_call_3',
+        loopIndex: 1,
+        agent: {},
+      }
+    );
+    const directPayload = parseOutput<{ buffer: { bufferId: string } }>(direct.output);
+
+    const finalize = await tool.execute({
+      path: target,
+      mode: 'finalize',
+      bufferId: directPayload.buffer.bufferId,
+    });
+    const finalizePayload = parseOutput<{ ok: boolean; code: string; nextAction: string }>(
+      finalize.output
+    );
+    expect(finalizePayload).toMatchObject({
+      ok: true,
+      code: 'WRITE_FILE_FINALIZE_OK',
+      nextAction: 'none',
+    });
+    expect(await fs.readFile(target, 'utf8')).toBe(content);
+  });
+
+  it('finalizes a buffered direct write by bufferId without requiring path and keeps full content', async () => {
+    const allowedDir = await createTempDir();
+    const bufferDir = await createTempDir();
+    const tool = new WriteFileTool({
+      allowedDirectories: [allowedDir],
+      bufferBaseDir: bufferDir,
+      maxChunkBytes: 8,
+    });
+    const target = path.join(allowedDir, 'finalize-by-buffer-id.txt');
+    const content = 'abcdefghijklmno';
+
+    const direct = await tool.execute(
+      {
+        path: target,
+        content,
+        mode: 'direct',
+      },
+      {
+        toolCallId: 'write_call_finalize_by_id',
+        loopIndex: 1,
+        agent: {},
+      }
+    );
+    const directPayload = parseOutput<{ ok: boolean; buffer: { bufferId: string } }>(direct.output);
+    expect(directPayload.ok).toBe(false);
+
+    const finalize = await tool.execute({
+      mode: 'finalize',
+      bufferId: directPayload.buffer.bufferId,
+    } as never);
+    const finalizePayload = parseOutput<{ ok: boolean; code: string; nextAction: string }>(
+      finalize.output
+    );
+    expect(finalizePayload).toMatchObject({
+      ok: true,
+      code: 'WRITE_FILE_FINALIZE_OK',
+      nextAction: 'none',
+    });
+    expect(await fs.readFile(target, 'utf8')).toBe(content);
+  });
+
+  it('finalizes an orphaned buffered session by scanning meta/rawArgs when pointer is missing', async () => {
+    const allowedDir = await createTempDir();
+    const bufferDir = await createTempDir();
+    const tool = new WriteFileTool({
+      allowedDirectories: [allowedDir],
+      bufferBaseDir: bufferDir,
+      maxChunkBytes: 8,
+    });
+    const target = path.join(allowedDir, 'finalize-orphaned-session.txt');
+    const content = 'orphaned buffered content';
+    const session = await createWriteBufferSession({
+      messageId: 'msg_orphaned',
+      toolCallId: 'write_call_orphaned',
+      baseDir: bufferDir,
+    });
+
+    await appendRawArgs(
+      session,
+      JSON.stringify({
+        mode: 'direct',
+        path: target,
+        content,
+      })
+    );
+    await appendContent(session, content);
+
+    const finalize = await tool.execute({
+      mode: 'finalize',
+      bufferId: session.bufferId,
+    } as never);
+    const payload = parseOutput<{ ok: boolean; code: string; nextAction: string }>(finalize.output);
+
+    expect(payload).toMatchObject({
+      ok: true,
+      code: 'WRITE_FILE_FINALIZE_OK',
+      nextAction: 'none',
+    });
+    expect(await fs.readFile(target, 'utf8')).toBe(content);
+  });
+
+  it('returns NEED_FINALIZE when finalize is missing bufferId', async () => {
+    const allowedDir = await createTempDir();
+    const bufferDir = await createTempDir();
+    const tool = new WriteFileTool({
+      allowedDirectories: [allowedDir],
+      bufferBaseDir: bufferDir,
+      maxChunkBytes: 8,
+    });
+    const payload = parseOutput<{
+      ok: boolean;
+      code: string;
+      nextAction: string;
+    }>(
+      (
+        await tool.execute({
+          mode: 'finalize',
+        } as never)
+      ).output
+    );
+
+    expect(payload.ok).toBe(false);
+    expect(payload.code).toBe('WRITE_FILE_NEED_FINALIZE');
+    expect(payload.nextAction).toBe('finalize');
+  });
+
+  it('prevents finalize from committing buffered content to a different target path', async () => {
+    const allowedDir = await createTempDir();
+    const bufferDir = await createTempDir();
+    const tool = new WriteFileTool({
+      allowedDirectories: [allowedDir],
+      bufferBaseDir: bufferDir,
+      maxChunkBytes: 8,
+    });
+    const targetA = path.join(allowedDir, 'target-a.txt');
+    const targetB = path.join(allowedDir, 'target-b.txt');
+
+    const direct = await tool.execute(
+      {
+        path: targetA,
+        content: 'abcdefghijk',
+        mode: 'direct',
+      },
+      {
+        toolCallId: 'write_call_path_mismatch',
+        loopIndex: 1,
+        agent: {},
+      }
+    );
+    const directPayload = parseOutput<{ buffer: { bufferId: string } }>(direct.output);
+
+    const finalize = await tool.execute({
+      path: targetB,
+      mode: 'finalize',
+      bufferId: directPayload.buffer.bufferId,
+    });
+    const payload = parseOutput<{ ok: boolean; code: string; message: string; nextAction: string }>(
+      finalize.output
+    );
+
+    expect(payload.ok).toBe(false);
+    expect(payload.code).toBe('WRITE_FILE_NEED_FINALIZE');
+    expect(payload.message).toContain('Target path does not match');
+    expect(payload.nextAction).toBe('finalize');
+    await expect(fs.readFile(targetB, 'utf8')).rejects.toBeDefined();
+  });
+
+  it('returns execution failure when path is outside allowed directories', async () => {
+    const allowedDir = await createTempDir();
+    const bufferDir = await createTempDir();
+    const tool = new WriteFileTool({
+      allowedDirectories: [allowedDir],
+      bufferBaseDir: bufferDir,
+      maxChunkBytes: 32,
+    });
+    const outside = path.resolve(allowedDir, '..', 'outside.txt');
+
+    const result = await tool.execute({
+      path: outside,
+      content: 'x',
+      mode: 'direct',
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.error?.name).toBe('ToolExecutionError');
+    expect(result.output).toContain('Path is outside allowed directories');
+  });
+});

package/vendor/agent-root/src/agent/tool/base-tool.ts

@@ -0,0 +1,345 @@
+import { z } from 'zod';
+import { LLMTool, ToolConcurrencyMode, ToolExecutionContext } from './types';
+import { ToolExecutionError } from './error';
+
+export type ToolParameterSchema = z.ZodType;
+
+interface ZodDef {
+  typeName?: string;
+  shape?: unknown;
+  description?: string;
+  checks?: Array<{
+    kind?: string;
+    value?: number;
+    regex?: { source: string };
+    check?: string;
+    minimum?: number;
+    maximum?: number;
+    pattern?: string | RegExp;
+    format?: string;
+    inclusive?: boolean;
+  }>;
+  type?: z.ZodType | string;
+  values?: unknown[];
+  entries?: Record<string, unknown>;
+  value?: unknown;
+  innerType?: z.ZodType;
+  defaultValue?: unknown;
+  left?: z.ZodType;
+  right?: z.ZodType;
+  valueType?: z.ZodType;
+  items?: z.ZodType[];
+  options?: z.ZodType[];
+  element?: z.ZodType;
+}
+
+function normalizeTypeName(rawTypeName?: string): string | undefined {
+  if (!rawTypeName) return undefined;
+  const trimmed = rawTypeName.trim();
+  if (!trimmed) return undefined;
+  const withoutPrefix = trimmed.startsWith('Zod') ? trimmed.slice(3) : trimmed;
+  return withoutPrefix.toLowerCase();
+}
+
+function getSchemaDef(schemaAny: unknown): ZodDef | undefined {
+  return ((schemaAny as { _zod_def?: ZodDef })._zod_def ||
+    (schemaAny as { _def?: ZodDef })._def) as ZodDef | undefined;
+}
+
+function getSchemaKind(schemaAny: unknown): string | undefined {
+  const def = getSchemaDef(schemaAny);
+  const rawType = (def as { type?: unknown } | undefined)?.type;
+  const fromTypeField = typeof rawType === 'string' ? rawType : undefined;
+  const nestedTypeName = (rawType as { _def?: { typeName?: string } } | undefined)?._def?.typeName;
+  return normalizeTypeName(def?.typeName || fromTypeField || nestedTypeName);
+}
+
+function zodToJsonSchema(schema: z.ZodType): Record<string, unknown> {
+  const schemaAny = schema as unknown;
+
+  if (typeof (z as unknown as { toJSONSchema?: unknown }).toJSONSchema === 'function') {
+    try {
+      const result = (z as unknown as { toJSONSchema: (s: z.ZodType) => unknown }).toJSONSchema(
+        schema
+      );
+      if (result && typeof result === 'object') {
+        return result as Record<string, unknown>;
+      }
+    } catch {
+      // fallback to local conversion
+    }
+  }
+
+  if (typeof (schemaAny as { toJSONSchema?: unknown }).toJSONSchema === 'function') {
+    try {
+      const result = (schemaAny as { toJSONSchema: () => Record<string, unknown> }).toJSONSchema();
+      if (result && typeof result === 'object') {
+        return result;
+      }
+    } catch {
+      // fallback to local conversion
+    }
+  }
+
+  const def = getSchemaDef(schemaAny);
+  const typeName = getSchemaKind(schemaAny);
+
+  if (typeName === 'object') {
+    const properties: Record<string, unknown> = {};
+    const required: string[] = [];
+
+    if (!def) return { type: 'object' };
+
+    const shape = typeof def.shape === 'function' ? (def.shape as () => unknown)() : def.shape;
+
+    for (const [key, value] of Object.entries(shape as Record<string, unknown>)) {
+      const valueAny = value as unknown;
+      properties[key] = zodToJsonSchema(valueAny as z.ZodType);
+
+      const propTypeName = getSchemaKind(valueAny);
+      if (propTypeName !== 'optional' && propTypeName !== 'default') {
+        required.push(key);
+      }
+    }
+
+    return {
+      type: 'object',
+      properties,
+      required: required.length > 0 ? required : undefined,
+    };
+  }
+
+  if (typeName === 'string') {
+    const result: Record<string, unknown> = { type: 'string' };
+    if (def?.description) {
+      result.description = def.description;
+    }
+    if (def?.checks) {
+      for (const check of def.checks) {
+        const checkKind = check.kind || check.check;
+        if (checkKind === 'min') {
+          result.minLength = check.value;
+        } else if (checkKind === 'max') {
+          result.maxLength = check.value;
+        } else if (checkKind === 'regex') {
+          result.pattern = check.regex?.source;
+        } else if (checkKind === 'min_length') {
+          result.minLength = check.minimum;
+        } else if (checkKind === 'max_length') {
+          result.maxLength = check.maximum;
+        } else if (checkKind === 'string_format' && check.format === 'regex') {
+          result.pattern =
+            typeof check.pattern === 'string'
+              ? check.pattern
+              : check.pattern instanceof RegExp
+                ? check.pattern.source
+                : undefined;
+        }
+      }
+    }
+    return result;
+  }
+
+  if (typeName === 'number') {
+    const result: Record<string, unknown> = { type: 'number' };
+    if (def?.description) {
+      result.description = def.description;
+    }
+    if (def?.checks) {
+      for (const check of def.checks) {
+        const checkKind = check.kind || check.check;
+        if (checkKind === 'min') {
+          result.minimum = check.value;
+        } else if (checkKind === 'max') {
+          result.maximum = check.value;
+        } else if (checkKind === 'int') {
+          result.type = 'integer';
+        } else if (checkKind === 'greater_than') {
+          if (check.inclusive) {
+            result.minimum = check.value;
+          } else {
+            result.exclusiveMinimum = check.value;
+          }
+        } else if (checkKind === 'less_than') {
+          if (check.inclusive) {
+            result.maximum = check.value;
+          } else {
+            result.exclusiveMaximum = check.value;
+          }
+        } else if (checkKind === 'number_format') {
+          result.type = 'integer';
+        }
+      }
+    }
+    return result;
+  }
+
+  if (typeName === 'boolean') {
+    return {
+      type: 'boolean',
+      ...(def?.description && { description: def.description }),
+    };
+  }
+
+  if (typeName === 'array') {
+    const itemSchema = def?.element || (def?.type as z.ZodType | undefined);
+    return {
+      type: 'array',
+      items: itemSchema ? zodToJsonSchema(itemSchema as z.ZodType) : {},
+      ...(def?.description && { description: def.description }),
+    };
+  }
+
+  if (typeName === 'enum') {
+    const enumValues = def?.values || (def?.entries ? Object.values(def.entries) : []);
+    return {
+      type: 'string',
+      enum: enumValues,
+      ...(def?.description && { description: def.description }),
+    };
+  }
+
+  if (typeName === 'literal') {
+    const value = def?.value ?? def?.values?.[0];
+    if (typeof value === 'string') {
+      return { type: 'string', const: value };
+    }
+    if (typeof value === 'number') {
+      return { type: 'number', const: value };
+    }
+    if (typeof value === 'boolean') {
+      return { type: 'boolean', const: value };
+    }
+    return { const: value };
+  }
+
+  if (typeName === 'optional') {
+    return def?.innerType ? zodToJsonSchema(def.innerType as unknown as z.ZodType) : {};
+  }
+
+  if (typeName === 'default') {
+    const innerSchema = def?.innerType
+      ? zodToJsonSchema(def.innerType as unknown as z.ZodType)
+      : {};
+    return {
+      ...innerSchema,
+      default:
+        typeof def?.defaultValue === 'function'
+          ? (def.defaultValue as () => unknown)()
+          : def?.defaultValue,
+    };
+  }
+
+  if (typeName === 'nullable') {
+    const innerSchema = def?.innerType
+      ? zodToJsonSchema(def.innerType as unknown as z.ZodType)
+      : {};
+    return {
+      ...innerSchema,
+      nullable: true,
+    };
+  }
+
+  if (typeName === 'union') {
+    return {
+      oneOf:
+        def?.options?.map((option: z.ZodType) => zodToJsonSchema(option as unknown as z.ZodType)) ||
+        [],
+    };
+  }
+
+  if (typeName === 'intersection') {
+    return {
+      allOf: [
+        def?.left ? zodToJsonSchema(def.left as unknown as z.ZodType) : {},
+        def?.right ? zodToJsonSchema(def.right as unknown as z.ZodType) : {},
+      ],
+    };
+  }
+
+  if (typeName === 'record') {
+    return {
+      type: 'object',
+      additionalProperties: def?.valueType
+        ? zodToJsonSchema(def.valueType as unknown as z.ZodType)
+        : {},
+    };
+  }
+
+  if (typeName === 'tuple') {
+    return {
+      type: 'array',
+      items:
+        def?.items?.map((item: z.ZodType) => zodToJsonSchema(item as unknown as z.ZodType)) || [],
+    };
+  }
+
+  if (typeName === 'null') {
+    return { type: 'null' };
+  }
+
+  if (typeName === 'any' || typeName === 'unknown') {
+    return {};
+  }
+
+  return {};
+}
+
+export interface ToolResult {
+  success: boolean;
+  output?: string;
+  summary?: string;
+  payload?: unknown;
+  error?: ToolExecutionError;
+  metadata?: Record<string, unknown>;
+}
+
+export interface ToolConfirmDetails {
+  reason?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export abstract class BaseTool<T extends ToolParameterSchema = ToolParameterSchema> {
+  abstract name: string;
+  abstract description: string;
+  abstract parameters: T;
+
+  shouldConfirm(_args: z.input<T>): boolean {
+    return false;
+  }
+
+  getConfirmDetails(_args: z.input<T>): ToolConfirmDetails | null {
+    return null;
+  }
+
+  getConcurrencyMode(_args: z.input<T>): ToolConcurrencyMode {
+    return 'exclusive';
+  }
+
+  getConcurrencyLockKey(_args: z.input<T>): string | undefined {
+    return undefined;
+  }
+
+  abstract execute(args: z.input<T>, context?: ToolExecutionContext): Promise<ToolResult>;
+
+  safeValidateArgs(
+    args: Record<string, unknown>
+  ): { success: true; data: z.infer<T> } | { success: false; error: z.ZodError } {
+    const result = this.parameters.safeParse(args);
+    if (result.success) {
+      return { success: true, data: result.data };
+    }
+    return { success: false, error: result.error };
+  }
+
+  toToolSchema(): LLMTool {
+    return {
+      type: 'function',
+      function: {
+        name: this.name,
+        description: this.description,
+        parameters: zodToJsonSchema(this.parameters),
+      },
+    };
+  }
+}