clawmini 0.0.3 → 0.0.5

package/src/daemon/agent/types.ts

@@ -0,0 +1,84 @@
+import type {
+  ChatMessage,
+  CommandLogMessage,
+  UserMessage,
+  SystemMessage,
+  AgentReplyMessage,
+  ToolMessage,
+  PolicyRequestMessage,
+  SubagentStatusMessage,
+} from '../chats.js';
+
+export interface Logger {
+  append<T extends ChatMessage>(msg: T): Promise<T>;
+  getMessages(limit?: number): Promise<ChatMessage[]>;
+  findLastMessage(predicate: (msg: ChatMessage) => boolean): Promise<ChatMessage | null>;
+  logUserMessage(msg: string): Promise<UserMessage>;
+  logSystemEvent(options: {
+    content: string;
+    level?: 'default' | 'debug' | 'verbose';
+  }): Promise<CommandLogMessage>;
+  logAutomaticReply(options: { messageId: string; content: string }): Promise<SystemMessage>;
+  logCommandRetry(options: {
+    messageId: string;
+    content: string;
+    cwd: string;
+  }): Promise<CommandLogMessage>;
+  logCommandResult(options: ExecutionResponse): Promise<CommandLogMessage>;
+  logSystemMessage(options: {
+    content: string;
+    event: SystemMessage['event'];
+    messageId?: string;
+    displayRole?: 'user' | 'agent';
+  }): Promise<SystemMessage>;
+  logSubagentStatus(options: {
+    subagentId: string;
+    status: 'completed' | 'failed';
+  }): Promise<SubagentStatusMessage>;
+  logAgentReply(options: { content: string; files?: string[] }): Promise<AgentReplyMessage>;
+  logToolMessage(options: {
+    content: string;
+    messageId: string;
+    name: string;
+    payload: unknown;
+  }): Promise<ToolMessage>;
+  logPolicyRequestMessage(options: {
+    content: string;
+    messageId: string;
+    requestId: string;
+    commandName: string;
+    args: string[];
+    status: 'pending' | 'approved' | 'rejected';
+  }): Promise<PolicyRequestMessage>;
+}
+
+export interface Message {
+  id: string;
+  content: string;
+  env: Record<string, string>;
+}
+
+export interface ExecutionResponse {
+  messageId: string;
+  content: string;
+  command: string;
+  cwd: string;
+  result: RunCommandResult;
+  extractedSessionId?: string | undefined;
+}
+
+export type RunCommandResult = {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+};
+
+export type RunCommandFn = (args: {
+  command: string;
+  cwd: string;
+  env: Record<string, string>;
+  stdin?: string | undefined;
+  signal?: AbortSignal | undefined;
+}) => Promise<RunCommandResult>;
+
+export type MaybePromise<T> = T | Promise<T>;

package/src/daemon/agent/utils.ts

@@ -0,0 +1,7 @@
+export function formatPendingMessages(payloads: string[]): string {
+  return payloads.map((text) => `<message>\n${text}\n</message>`).join('\n\n');
+}
+
+export function isNewSession(env: Record<string, string>): boolean {
+  return env['SESSION_ID'] === undefined;
+}

package/src/daemon/api/agent-router.ts

@@ -2,15 +2,21 @@ import { z } from 'zod';
 import { randomUUID } from 'node:crypto';
 import path from 'node:path';
 import { TRPCError } from '@trpc/server';
-import { appendMessage, type CommandLogMessage } from '../chats.js';
-import { executeSafe, generateRequestPreview } from '../policy-utils.js';
+import {
+  appendMessage,
+  type CommandLogMessage,
+  type AgentReplyMessage,
+  type ToolMessage,
+  type PolicyRequestMessage,
+} from '../chats.js';
+import { executeSafe, generateRequestPreview, executeRequest } from '../policy-utils.js';
 import { getWorkspaceRoot, readPolicies, getClawminiDir } from '../../shared/workspace.js';
 import { PolicyRequestService } from '../policy-request-service.js';
 import { RequestStore } from '../request-store.js';
 import { CronJobSchema } from '../../shared/config.js';
 import { apiProcedure, router } from './trpc.js';
-import { getMessageQueue } from '../queue.js';
-import { formatPendingMessages } from '../message.js';
+import { taskScheduler } from '../agent/task-scheduler.js';
+import { formatPendingMessages } from '../agent/utils.js';
 import {
   resolveAgentDir,
   validateLogFile,
@@ -48,14 +54,52 @@ export const logMessage = apiProcedure
     const logMsg: CommandLogMessage = {
       id,
       messageId: id,
-      role: 'log',
-      source: 'router',
+      role: 'command',
       content: messageStr,
+      stdout: '',
       stderr: '',
       timestamp,
       command: `clawmini-lite log${filesArgStr}`,
       cwd: process.cwd(),
       exitCode: 0,
+      ...(ctx.tokenPayload.subagentId ? { subagentId: ctx.tokenPayload.subagentId } : {}),
+      ...(filePaths.length > 0 ? { files: filePaths } : {}),
+    };
+
+    await appendMessage(chatId, logMsg);
+    return { success: true };
+  });
+
+export const logReplyMessage = apiProcedure
+  .input(
+    z.object({
+      message: z.string(),
+      files: z.array(z.string()).optional(),
+    })
+  )
+  .mutation(async ({ input, ctx }) => {
+    if (!ctx.tokenPayload) throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Missing token' });
+    const chatId = ctx.tokenPayload.chatId;
+    const timestamp = new Date().toISOString();
+    const id = Date.now().toString() + Math.random().toString(36).substring(2, 7);
+
+    const filePaths: string[] = [];
+    if (input.files && input.files.length > 0) {
+      const workspaceRoot = getWorkspaceRoot(process.cwd());
+      const agentDir = await resolveAgentDir(ctx.tokenPayload?.agentId, workspaceRoot);
+
+      for (const file of input.files) {
+        const validPath = await validateLogFile(file, agentDir, workspaceRoot);
+        filePaths.push(validPath);
+      }
+    }
+
+    const logMsg: AgentReplyMessage = {
+      id,
+      role: 'agent',
+      content: input.message,
+      timestamp,
+      ...(ctx.tokenPayload.subagentId ? { subagentId: ctx.tokenPayload.subagentId } : {}),
       ...(filePaths.length > 0 ? { files: filePaths } : {}),
     };
 
@@ -63,6 +107,47 @@ export const logMessage = apiProcedure
     return { success: true };
   });
 
+export const logToolMessage = apiProcedure
+  .input(
+    z.object({
+      name: z.string(),
+      payload: z.any().optional(),
+    })
+  )
+  .mutation(async ({ input, ctx }) => {
+    if (!ctx.tokenPayload) throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Missing token' });
+    const chatId = ctx.tokenPayload.chatId;
+    const timestamp = new Date().toISOString();
+    const id = Date.now().toString() + Math.random().toString(36).substring(2, 7);
+    const messageId = randomUUID();
+
+    const payloadObj = input.payload !== undefined ? input.payload : {};
+    let contentStr: string;
+    if (typeof payloadObj === 'string') {
+      contentStr = payloadObj;
+    } else {
+      try {
+        contentStr = JSON.stringify(payloadObj, null, 2);
+      } catch {
+        contentStr = String(payloadObj);
+      }
+    }
+
+    const logMsg: ToolMessage = {
+      id,
+      messageId,
+      role: 'tool',
+      name: input.name,
+      payload: payloadObj,
+      content: contentStr,
+      timestamp,
+      ...(ctx.tokenPayload.subagentId ? { subagentId: ctx.tokenPayload.subagentId } : {}),
+    };
+
+    await appendMessage(chatId, logMsg);
+    return { success: true };
+  });
+
 export const agentListCronJobs = apiProcedure.query(async ({ ctx }) => {
   if (!ctx.tokenPayload) throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Missing token' });
   const chatId = ctx.tokenPayload.chatId;
@@ -134,28 +219,70 @@ export const createPolicyRequest = apiProcedure
     const chatId = ctx.tokenPayload.chatId;
     const agentId = ctx.tokenPayload.agentId;
 
+    const config = await readPolicies();
+    const policy = config?.policies?.[input.commandName];
+
+    if (!policy) {
+      throw new TRPCError({
+        code: 'NOT_FOUND',
+        message: `Policy not found: ${input.commandName}`,
+      });
+    }
+
+    const isAutoApprove = !!policy.autoApprove;
+
     const request = await service.createRequest(
       input.commandName,
       input.args,
       input.fileMappings,
       chatId,
-      agentId
+      agentId,
+      isAutoApprove,
+      ctx.tokenPayload.subagentId
     );
 
+    if (isAutoApprove) {
+      const { stdout, stderr, exitCode, commandStr } = await executeRequest(
+        request,
+        policy,
+        getWorkspaceRoot()
+      );
+
+      request.executionResult = { stdout, stderr, exitCode };
+      await store.save(request);
+
+      const logMsg: PolicyRequestMessage = {
+        id: randomUUID(),
+        // TODO: we should store the message ID in the CLAW_API_TOKEN, and extract it here
+        messageId: randomUUID(),
+        role: 'policy',
+        requestId: request.id,
+        commandName: input.commandName,
+        args: input.args,
+        status: 'approved',
+        content: `[Auto-approved] Policy ${input.commandName} was executed.\n\nCommand: ${commandStr}\nExit Code: ${exitCode}\n\nStdout:\n${stdout}\n\nStderr:\n${stderr}`,
+        timestamp: new Date().toISOString(),
+        ...(ctx.tokenPayload.subagentId ? { subagentId: ctx.tokenPayload.subagentId } : {}),
+      };
+
+      await appendMessage(chatId, logMsg);
+      return request;
+    }
+
     const previewContent = await generateRequestPreview(request);
 
-    const logMsg = {
+    const logMsg: PolicyRequestMessage = {
       id: randomUUID(),
       // TODO: we should store the message ID in the CLAW_API_TOKEN, and extract it here
       messageId: randomUUID(),
-      role: 'log' as const,
-      source: 'router' as const,
+      role: 'policy',
+      requestId: request.id,
+      commandName: input.commandName,
+      args: input.args,
+      status: 'pending',
       content: previewContent,
-      stderr: '',
       timestamp: new Date().toISOString(),
-      command: 'policy-request',
-      cwd: process.cwd(),
-      exitCode: 0,
+      displayRole: 'agent',
     };
 
     await appendMessage(chatId, logMsg);
@@ -165,19 +292,33 @@ export const createPolicyRequest = apiProcedure
 import { ping } from './user-router.js';
 
 export const fetchPendingMessages = apiProcedure.mutation(async ({ ctx }) => {
-  const cwd = process.cwd();
-  const queue = getMessageQueue(cwd);
+  if (!ctx.tokenPayload?.agentId) {
+    throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Missing agent ID' });
+  }
   const targetSessionId = ctx.tokenPayload?.sessionId || 'default';
 
-  const extracted = queue.extractPending((p) => p.sessionId === targetSessionId);
+  const extracted = taskScheduler.extractPending(targetSessionId);
   if (extracted.length === 0) {
     return { messages: '' };
   }
-  return { messages: formatPendingMessages(extracted.map((p) => p.text)) };
+
+  return { messages: formatPendingMessages(extracted) };
 });
 
+import {
+  subagentSpawn,
+  subagentSend,
+  subagentWait,
+  subagentStop,
+  subagentDelete,
+  subagentList,
+  subagentTail,
+} from './subagent-router.js';
+
 export const agentRouter = router({
   logMessage,
+  logReplyMessage,
+  logToolMessage,
   listCronJobs: agentListCronJobs,
   addCronJob: agentAddCronJob,
   deleteCronJob: agentDeleteCronJob,
@@ -186,6 +327,13 @@ export const agentRouter = router({
   createPolicyRequest,
   fetchPendingMessages,
   ping,
+  subagentSpawn,
+  subagentSend,
+  subagentWait,
+  subagentStop,
+  subagentDelete,
+  subagentList,
+  subagentTail,
 });
 
 export type AgentRouter = typeof agentRouter;

package/src/daemon/api/index.test.ts

@@ -6,7 +6,7 @@ import * as workspace from '../../shared/workspace.js';
 import * as chats from '../../shared/chats.js';
 import type { CronJob } from '../../shared/config.js';
 import * as message from '../message.js';
-import { getMessageQueue } from '../queue.js';
+import { taskScheduler } from '../agent/task-scheduler.js';
 import * as fs from 'node:fs/promises';
 import path from 'node:path';
 
@@ -46,6 +46,7 @@ vi.mock('../../shared/workspace.js', async (importOriginal) => {
   const actual = await importOriginal<typeof import('../../shared/workspace.js')>();
   return {
     ...actual,
+    readSettings: vi.fn().mockResolvedValue(null),
     readChatSettings: vi.fn(),
     writeChatSettings: vi.fn(),
     getSettingsPath: vi.fn().mockReturnValue('/mock/settings.json'),
@@ -169,7 +170,6 @@ describe('Daemon TRPC Router', () => {
         {},
         undefined,
         false,
-        expect.any(Function),
         undefined,
         undefined
       );
@@ -300,7 +300,7 @@ describe('Daemon TRPC Router', () => {
       expect(chats.appendMessage).toHaveBeenCalledWith(
         'default-chat',
         expect.objectContaining({
-          role: 'log',
+          role: 'command',
           content: 'Test log',
         }),
         expect.any(String)
@@ -325,7 +325,7 @@ describe('Daemon TRPC Router', () => {
       expect(chats.appendMessage).toHaveBeenCalledWith(
         'default-chat',
         expect.objectContaining({
-          role: 'log',
+          role: 'command',
           content: 'Test log with file',
           files: [path.normalize('attachments/discord/image.png')],
         }),
@@ -393,10 +393,9 @@ describe('Daemon TRPC Router', () => {
   });
 
   describe('fetchPendingMessages', () => {
-    let queue: ReturnType<typeof getMessageQueue>;
     beforeEach(() => {
-      queue = getMessageQueue(process.cwd());
-      queue.clear();
+      taskScheduler.abortTasks('s1');
+      taskScheduler.abortTasks('s2');
     });
 
     it('should extract pending messages from queue matching the session and format them', async () => {
@@ -406,21 +405,54 @@ describe('Daemon TRPC Router', () => {
       });
 
       // The first task will start and block, leaving the others in pending
-      queue.enqueue(
-        async () => {
+      taskScheduler.schedule({
+        id: 't1',
+        rootChatId: 'c1',
+        dirPath: 'd1',
+        sessionId: 's1',
+        execute: async () => {
           await firstTaskPromise;
         },
-        { text: 'Task 1', sessionId: 's1' }
-      );
+      });
 
       // These will stay in pending
-      const p2 = queue.enqueue(async () => {}, { text: 'Task 2', sessionId: 's1' });
-      const p3 = queue.enqueue(async () => {}, { text: 'Task 3', sessionId: 's1' });
-      const p4 = queue.enqueue(async () => {}, { text: 'Task 4', sessionId: 's2' });
+      const p2 = taskScheduler.schedule({
+        id: 't2',
+        rootChatId: 'c1', // force block
+        dirPath: 'd1',
+        sessionId: 's1',
+        text: 'Task 2',
+        execute: async () => {},
+      });
+      const p3 = taskScheduler.schedule({
+        id: 't3',
+        rootChatId: 'c1', // force block
+        dirPath: 'd1',
+        sessionId: 's1',
+        text: 'Task 3',
+        execute: async () => {},
+      });
+      const p3_5 = taskScheduler.schedule({
+        id: 't3_5',
+        rootChatId: 'c2', // force block
+        dirPath: 'd1',
+        sessionId: 's2',
+        text: 'Task 3.5',
+        execute: async () => {},
+      });
+      const p4 = taskScheduler.schedule({
+        id: 't4',
+        rootChatId: 'c2',
+        dirPath: 'd1',
+        sessionId: 's2',
+        text: 'Task 4',
+        execute: async () => {},
+      });
 
       // We expect them to throw AbortError when extracted
       p2.catch(() => {});
       p3.catch(() => {});
+      p3_5.catch(() => {});
       p4.catch(() => {});
 
       const caller = agentRouter.createCaller({
@@ -431,15 +463,15 @@ describe('Daemon TRPC Router', () => {
       expect(result.messages).toBe(
         '<message>\nTask 2\n</message>\n\n<message>\nTask 3\n</message>'
       );
-      expect(queue.extractPending((p) => p.sessionId === 's2')).toEqual([
-        { text: 'Task 4', sessionId: 's2' },
-      ]);
+      expect(taskScheduler.extractPending('s2')).toEqual(['Task 4']);
 
       resolveFirstTask!(); // cleanup
     });
 
     it('should return empty string if no pending messages', async () => {
-      const caller = agentRouter.createCaller({});
+      const caller = agentRouter.createCaller({
+        tokenPayload: { agentId: 'test', sessionId: 's1' } as any,
+      });
       const result = await caller.fetchPendingMessages();
       expect(result.messages).toBe('');
     });

package/src/daemon/api/policy-request.test.ts

@@ -11,6 +11,18 @@ vi.mock('../../shared/chats.js', () => ({
 vi.mock('../../shared/workspace.js', () => ({
   getWorkspaceRoot: vi.fn().mockReturnValue('/mock/workspace'),
   getClawminiDir: vi.fn().mockReturnValue('/mock/.clawmini'),
+  readPolicies: vi.fn().mockResolvedValue({
+    policies: {
+      'test-cmd': {
+        command: 'echo',
+        autoApprove: false,
+      },
+      'auto-cmd': {
+        command: 'echo',
+        autoApprove: true,
+      },
+    },
+  }),
 }));
 
 vi.mock('../policy-request-service.js', () => {
@@ -46,11 +58,13 @@ vi.mock('node:fs/promises', async (importOriginal) => {
     default: {
       ...actual,
       readFile: mockReadFile,
+      writeFile: vi.fn(),
       mkdir: vi.fn(),
       readdir: vi.fn().mockResolvedValue([]),
       realpath: vi.fn().mockImplementation((p) => Promise.resolve(p)),
     },
     readFile: mockReadFile,
+    writeFile: vi.fn(),
     mkdir: vi.fn(),
     readdir: vi.fn().mockResolvedValue([]),
     realpath: vi.fn().mockImplementation((p) => Promise.resolve(p)),
@@ -95,8 +109,7 @@ describe('createPolicyRequest preview message', () => {
     const logMsg = callArgs[1] as any;
 
     expect(chatId).toBe('default-chat');
-    expect(logMsg.role).toBe('log');
-    expect(logMsg.command).toBe('policy-request');
+    expect(logMsg.role).toBe('policy');
 
     // Assert preview content format
     const content = logMsg.content;
@@ -110,4 +123,28 @@ describe('createPolicyRequest preview message', () => {
     expect(content).toContain('File [file2]:\n' + 'A'.repeat(500) + '\n... (truncated)');
     expect(content).toContain('Use /approve req-123 or /reject req-123 [reason]');
   });
+
+  it('should create an auto-approved request and execute it immediately', async () => {
+    const caller = appRouter.createCaller({
+      isApiServer: true,
+      tokenPayload: { agentId: 'default', chatId: 'default-chat' },
+    } as any);
+
+    const result = await caller.createPolicyRequest({
+      commandName: 'auto-cmd',
+      args: ['hello'],
+      fileMappings: {},
+    });
+
+    expect(result.id).toBe('REQ-123');
+    expect(result.executionResult).toBeDefined();
+
+    expect(chats.appendMessage).toHaveBeenCalledTimes(1);
+    const callArgs = vi.mocked(chats.appendMessage).mock.calls[0]!;
+    const logMsg = callArgs[1] as any;
+
+    expect(logMsg.content).toContain('[Auto-approved] Policy auto-cmd was executed.');
+    expect(logMsg.role).toBe('policy');
+    expect(logMsg.status).toBe('approved');
+  });
 });

package/src/daemon/api/subagent-router.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { agentRouter } from './agent-router.js';
+import { daemonEvents, DAEMON_EVENT_MESSAGE_APPENDED } from '../events.js';
+import * as workspace from '../../shared/workspace.js';
+
+vi.mock('../../shared/workspace.js', () => ({
+  readChatSettings: vi.fn(),
+  updateChatSettings: vi.fn(),
+  getWorkspaceRoot: vi.fn().mockReturnValue('/mock/root'),
+}));
+
+vi.mock('../agent/chat-logger.js', () => ({
+  createChatLogger: vi.fn(() => ({
+    findLastMessage: vi.fn().mockResolvedValue({ role: 'log', content: 'Mock output' }),
+  })),
+}));
+
+describe('subagentWait', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    daemonEvents.removeAllListeners();
+  });
+
+  it('should not miss events if subagent completes immediately after checkSubagentStatus starts', async () => {
+    // We simulate checkSubagentStatus taking some time (e.g. reading from disk).
+    // While it is awaiting, an event is emitted indicating completion.
+    // The wait procedure should still catch the completion.
+
+    const subagentId = 'sub-1';
+    const chatId = 'chat-1';
+
+    let firstCall = true;
+
+    vi.mocked(workspace.readChatSettings).mockImplementation(async (_id: string) => {
+      if (firstCall) {
+        firstCall = false;
+        // Emit the event while the first check is "in flight"
+        // This simulates the race condition where the status is "active" at the exact moment
+        // of reading, but changes immediately after before the event listener would be bound in the buggy code.
+        setTimeout(() => {
+          daemonEvents.emit(DAEMON_EVENT_MESSAGE_APPENDED, {
+            chatId,
+            message: { role: 'subagent_status', status: 'completed', subagentId },
+          });
+        }, 10);
+
+        await new Promise((r) => setTimeout(r, 50));
+        return {
+          subagents: {
+            [subagentId]: { status: 'active', id: subagentId, createdAt: '2023-01-01' },
+          },
+        };
+      } else {
+        return {
+          subagents: {
+            [subagentId]: { status: 'completed', id: subagentId, createdAt: '2023-01-01' },
+          },
+        };
+      }
+    });
+
+    const ctx = {
+      tokenPayload: { chatId, agentId: 'agent', sessionId: 'session' },
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const caller = agentRouter.createCaller(ctx as any);
+
+    const resultPromise = caller.subagentWait({ subagentId });
+
+    // We don't want the test to hang if the bug is present, so we use Promise.race
+    const timeoutPromise = new Promise((_, reject) =>
+      setTimeout(() => reject(new Error('Timeout - event missed')), 500)
+    );
+
+    const result = await Promise.race([resultPromise, timeoutPromise]);
+    expect(result).toEqual({ status: 'completed', output: 'Mock output' });
+  });
+
+  it('should clean up the event listener if it returns early due to initial status check', async () => {
+    const subagentId = 'sub-2';
+    const chatId = 'chat-2';
+
+    // Mock an immediate completed status
+    vi.mocked(workspace.readChatSettings).mockResolvedValue({
+      subagents: {
+        [subagentId]: { status: 'completed', id: subagentId, createdAt: '2023-01-01' },
+      },
+    });
+
+    const ctx = {
+      tokenPayload: { chatId, agentId: 'agent', sessionId: 'session' },
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const caller = agentRouter.createCaller(ctx as any);
+
+    const initialListeners = daemonEvents.listenerCount(DAEMON_EVENT_MESSAGE_APPENDED);
+
+    const result = await caller.subagentWait({ subagentId });
+
+    expect(result).toEqual({ status: 'completed', output: 'Mock output' });
+
+    const finalListeners = daemonEvents.listenerCount(DAEMON_EVENT_MESSAGE_APPENDED);
+    expect(finalListeners).toBe(initialListeners); // Should not leave any lingering listeners
+  });
+});