@renxqoo/renx-code 0.0.4 → 0.0.6

package/vendor/agent-root/src/agent/tool/__test__/task-parent-abort.test.ts

@@ -0,0 +1,287 @@
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { TaskStore } from '../task-store';
+import { attachParentAbortCascade, PARENT_ABORT_REASON } from '../task-parent-abort';
+import type { SubagentRunnerAdapter } from '../task-runner-adapter';
+import type { AgentRunEntity, TaskEntity } from '../task-types';
+import type { ToolExecutionContext, ToolStreamEventInput } from '../types';
+
+function makeRun(agentId: string, status: AgentRunEntity['status'] = 'cancelled'): AgentRunEntity {
+  const now = Date.now();
+  return {
+    agentId,
+    status,
+    subagentType: 'Plan',
+    prompt: 'p',
+    createdAt: now,
+    startedAt: now,
+    updatedAt: now,
+    metadata: {},
+    version: 1,
+  };
+}
+
+function makeTask(id: string, status: TaskEntity['status'], agentId?: string): TaskEntity {
+  const now = Date.now();
+  return {
+    id,
+    subject: id,
+    description: `${id} description long enough`,
+    activeForm: id,
+    status,
+    priority: 'normal',
+    owner: status === 'in_progress' ? `agent:${agentId || 'x'}` : null,
+    blockedBy: [],
+    blocks: [],
+    progress: 0,
+    checkpoints: [],
+    retryConfig: {
+      maxRetries: 3,
+      retryDelayMs: 100,
+      backoffMultiplier: 2,
+      retryOn: ['timeout'],
+    },
+    retryCount: 0,
+    tags: [],
+    metadata: {},
+    history: [],
+    agentId,
+    createdAt: now,
+    updatedAt: now,
+    version: 1,
+  };
+}
+
+function makeRunner(
+  cancelImpl: (
+    namespace: string,
+    agentId: string,
+    reason?: string
+  ) => Promise<AgentRunEntity | null>
+): SubagentRunnerAdapter {
+  return {
+    start: async () => makeRun('unused', 'running'),
+    poll: async () => null,
+    cancel: cancelImpl,
+  };
+}
+
+async function waitUntil(check: () => boolean | Promise<boolean>, timeoutMs = 1000): Promise<void> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (await check()) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+  throw new Error('Timed out waiting for condition');
+}
+
+async function rmDirWithRetry(dir: string): Promise<void> {
+  for (let attempt = 0; attempt < 5; attempt += 1) {
+    try {
+      await fs.rm(dir, { recursive: true, force: true });
+      return;
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code;
+      if (code !== 'ENOTEMPTY' && code !== 'EBUSY' && code !== 'EPERM') {
+        throw error;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+  }
+}
+
+function makeContext(signal: AbortSignal, chunks: ToolStreamEventInput[]): ToolExecutionContext {
+  return {
+    toolCallId: 'tc',
+    loopIndex: 1,
+    agent: {},
+    toolAbortSignal: signal,
+    onChunk: async (event) => {
+      chunks.push(event);
+    },
+  };
+}
+
+describe('task-parent-abort cascade', () => {
+  let baseDir: string;
+  let store: TaskStore;
+
+  beforeEach(async () => {
+    baseDir = await fs.mkdtemp(path.join(os.tmpdir(), 'renx-task-parent-abort-'));
+    store = new TaskStore({ baseDir });
+  });
+
+  afterEach(async () => {
+    await rmDirWithRetry(baseDir);
+  });
+
+  it('returns noop detach when context has no abort signal', async () => {
+    let cancelCalls = 0;
+    const runner = makeRunner(async () => {
+      cancelCalls += 1;
+      return makeRun('a1');
+    });
+
+    const detach = attachParentAbortCascade({
+      namespace: 'n1',
+      agentId: 'a1',
+      runner,
+      store,
+    });
+    detach();
+
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    expect(cancelCalls).toBe(0);
+  });
+
+  it('deduplicates abort callbacks and supports detach with custom signal', async () => {
+    let cancelCalls = 0;
+    let removed = false;
+    let registered: (() => void) | undefined;
+    const runner = makeRunner(async () => {
+      cancelCalls += 1;
+      return makeRun('a2');
+    });
+
+    const signal = {
+      aborted: true,
+      addEventListener: (_name: string, cb: () => void) => {
+        registered = cb;
+        cb();
+      },
+      removeEventListener: (_name: string, cb: () => void) => {
+        removed = registered === cb;
+      },
+    } as unknown as AbortSignal;
+
+    const detach = attachParentAbortCascade({
+      namespace: 'n1',
+      agentId: 'a2',
+      runner,
+      store,
+      context: makeContext(signal, []),
+    });
+
+    await waitUntil(() => cancelCalls === 1);
+    expect(cancelCalls).toBe(1);
+    detach();
+    expect(removed).toBe(true);
+  });
+
+  it('skips linked task updates when task missing, mismatched, or already terminal', async () => {
+    await store.updateState('n2', (state) => {
+      state.tasks.t_mismatch = makeTask('t_mismatch', 'in_progress', 'agent-other');
+      state.tasks.t_done = makeTask('t_done', 'completed', 'agent-main');
+      return null;
+    });
+
+    let cancelCalls = 0;
+    const runner = makeRunner(async () => {
+      cancelCalls += 1;
+      return makeRun('agent-main');
+    });
+
+    const chunks: ToolStreamEventInput[] = [];
+
+    const c1 = new AbortController();
+    attachParentAbortCascade({
+      namespace: 'n2',
+      agentId: 'agent-main',
+      linkedTaskId: 'missing',
+      runner,
+      store,
+      context: makeContext(c1.signal, chunks),
+    });
+    c1.abort();
+
+    const c2 = new AbortController();
+    attachParentAbortCascade({
+      namespace: 'n2',
+      agentId: 'agent-main',
+      linkedTaskId: 't_mismatch',
+      runner,
+      store,
+      context: makeContext(c2.signal, chunks),
+    });
+    c2.abort();
+
+    const c3 = new AbortController();
+    attachParentAbortCascade({
+      namespace: 'n2',
+      agentId: 'agent-main',
+      linkedTaskId: 't_done',
+      runner,
+      store,
+      context: makeContext(c3.signal, chunks),
+    });
+    c3.abort();
+
+    await waitUntil(() => cancelCalls === 3);
+    const state = await store.getState('n2');
+    expect(state.tasks.t_mismatch.status).toBe('in_progress');
+    expect(state.tasks.t_done.status).toBe('completed');
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  });
+
+  it('cancels linked task and writes parent-abort history', async () => {
+    await store.updateState('n3', (state) => {
+      state.tasks.t_active = makeTask('t_active', 'in_progress', 'agent-ok');
+      return null;
+    });
+
+    const chunks: ToolStreamEventInput[] = [];
+    const runner = makeRunner(async () => makeRun('agent-ok'));
+    const controller = new AbortController();
+
+    attachParentAbortCascade({
+      namespace: 'n3',
+      agentId: 'agent-ok',
+      linkedTaskId: 't_active',
+      runner,
+      store,
+      context: makeContext(controller.signal, chunks),
+    });
+    controller.abort();
+
+    await waitUntil(async () => {
+      const state = await store.getState('n3');
+      return state.tasks.t_active.status === 'cancelled';
+    });
+
+    const state = await store.getState('n3');
+    const task = state.tasks.t_active;
+    expect(task.status).toBe('cancelled');
+    expect(task.history.some((entry) => entry.actor === 'task-parent-abort')).toBe(true);
+    expect(task.history.some((entry) => entry.reason === PARENT_ABORT_REASON)).toBe(true);
+    expect(chunks.some((entry) => entry.type === 'info')).toBe(true);
+  });
+
+  it('emits stderr chunk when cancel throws non-Error value', async () => {
+    const chunks: ToolStreamEventInput[] = [];
+    const runner = makeRunner(async () => {
+      throw 'raw-failure';
+    });
+    const controller = new AbortController();
+
+    attachParentAbortCascade({
+      namespace: 'n4',
+      agentId: 'agent-fail',
+      runner,
+      store,
+      context: makeContext(controller.signal, chunks),
+    });
+    controller.abort();
+
+    await waitUntil(() =>
+      chunks.some(
+        (entry) =>
+          entry.type === 'stderr' &&
+          String(entry.content || '').includes('failed to cascade parent abort: raw-failure')
+      )
+    );
+  });
+});

package/vendor/agent-root/src/agent/tool/__test__/task-real-runner-adapter.test.ts

@@ -0,0 +1,190 @@
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { TaskStore } from '../task-store';
+import { RealSubagentRunnerAdapter } from '../task-runner-adapter';
+import type { RunRecord } from '../../app/contracts';
+import type { RunForegroundRequest, RunForegroundResult } from '../../app/agent-app-service';
+import type { Message } from '../../types';
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function makeRunRecord(
+  executionId: string,
+  conversationId: string,
+  status: RunRecord['status']
+): RunRecord {
+  const now = Date.now();
+  return {
+    executionId,
+    runId: executionId,
+    conversationId,
+    status,
+    createdAt: now,
+    updatedAt: now,
+    stepIndex: status === 'COMPLETED' ? 2 : 1,
+    startedAt: now,
+    completedAt: status === 'COMPLETED' || status === 'CANCELLED' ? now : undefined,
+    terminalReason:
+      status === 'COMPLETED' ? 'stop' : status === 'CANCELLED' ? 'aborted' : undefined,
+  };
+}
+
+class FakeSubagentExecutionService {
+  readonly runs = new Map<string, RunRecord>();
+  readonly contextMessages = new Map<string, Message[]>();
+  delayMs = 30;
+  completionText = 'subagent final answer';
+
+  async runForeground(request: RunForegroundRequest): Promise<RunForegroundResult> {
+    const executionId = request.executionId as string;
+    const conversationId = request.conversationId;
+    const running = makeRunRecord(executionId, conversationId, 'RUNNING');
+    this.runs.set(executionId, running);
+
+    const abortSignal = request.abortSignal;
+    if (abortSignal?.aborted) {
+      const cancelled = makeRunRecord(executionId, conversationId, 'CANCELLED');
+      this.runs.set(executionId, cancelled);
+      return {
+        executionId,
+        conversationId,
+        messages: [],
+        events: [],
+        finishReason: 'error',
+        steps: 1,
+        run: cancelled,
+      };
+    }
+
+    await sleep(this.delayMs);
+
+    if (abortSignal?.aborted) {
+      const cancelled = makeRunRecord(executionId, conversationId, 'CANCELLED');
+      this.runs.set(executionId, cancelled);
+      return {
+        executionId,
+        conversationId,
+        messages: [],
+        events: [],
+        finishReason: 'error',
+        steps: 1,
+        run: cancelled,
+      };
+    }
+
+    const assistantMessage: Message = {
+      messageId: `msg_${Date.now()}`,
+      role: 'assistant',
+      type: 'assistant-text',
+      content: this.completionText,
+      timestamp: Date.now(),
+    };
+    this.contextMessages.set(conversationId, [assistantMessage]);
+
+    const completed = makeRunRecord(executionId, conversationId, 'COMPLETED');
+    this.runs.set(executionId, completed);
+    return {
+      executionId,
+      conversationId,
+      messages: [assistantMessage],
+      events: [],
+      finishReason: 'stop',
+      steps: 2,
+      run: completed,
+    };
+  }
+
+  async getRun(executionId: string): Promise<RunRecord | null> {
+    return this.runs.get(executionId) || null;
+  }
+
+  async listContextMessages(conversationId: string): Promise<Message[]> {
+    return this.contextMessages.get(conversationId) || [];
+  }
+}
+
+describe('real subagent runner adapter', () => {
+  let baseDir: string;
+  let store: TaskStore;
+  let appService: FakeSubagentExecutionService;
+  let runner: RealSubagentRunnerAdapter;
+
+  beforeEach(async () => {
+    baseDir = await fs.mkdtemp(path.join(os.tmpdir(), 'renx-task-real-runner-'));
+    store = new TaskStore({ baseDir });
+    appService = new FakeSubagentExecutionService();
+    runner = new RealSubagentRunnerAdapter({
+      store,
+      appService,
+      resolveTools: (allowedTools) =>
+        (allowedTools || []).map((name) => ({
+          type: 'function',
+          function: {
+            name,
+            description: name,
+            parameters: {},
+          },
+        })),
+      resolveModelId: () => 'glm-5',
+    });
+  });
+
+  afterEach(async () => {
+    await fs.rm(baseDir, { recursive: true, force: true });
+  });
+
+  it('returns real foreground output instead of mock prompt echo', async () => {
+    const run = await runner.start('ns1', {
+      subagentType: 'Plan',
+      prompt: 'analyze codebase deeply',
+      runInBackground: false,
+      allowedTools: ['glob', 'grep'],
+    });
+
+    expect(run.status).toBe('completed');
+    expect(run.output).toBe('subagent final answer');
+    expect(run.output).not.toContain('completed: analyze codebase deeply');
+  });
+
+  it('does not expose partial output before completion in background mode', async () => {
+    appService.delayMs = 80;
+    const started = await runner.start('ns2', {
+      subagentType: 'Explore',
+      prompt: 'background investigation',
+      runInBackground: true,
+      allowedTools: ['glob'],
+    });
+    expect(started.status).toBe('running');
+
+    const inProgress = await runner.poll('ns2', started.agentId);
+    expect(inProgress?.status).toBe('running');
+    expect(inProgress?.output).toBeUndefined();
+
+    await sleep(120);
+    const completed = await runner.poll('ns2', started.agentId);
+    expect(completed?.status).toBe('completed');
+    expect(completed?.output).toBe('subagent final answer');
+  });
+
+  it('cancels live background run and reports cancelled status', async () => {
+    appService.delayMs = 200;
+    const started = await runner.start('ns3', {
+      subagentType: 'general-purpose',
+      prompt: 'long running operation',
+      runInBackground: true,
+      allowedTools: ['bash'],
+    });
+
+    const cancelled = await runner.cancel('ns3', started.agentId, 'stop now');
+    expect(cancelled?.status).toBe('cancelled');
+    expect(cancelled?.error).toBe('stop now');
+
+    await sleep(30);
+    const polled = await runner.poll('ns3', started.agentId);
+    expect(polled?.status).toBe('cancelled');
+  });
+});