clawmini 0.0.3 → 0.0.5

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

@@ -0,0 +1,296 @@
+import { z } from 'zod';
+import { randomUUID } from 'node:crypto';
+import { TRPCError } from '@trpc/server';
+import { getWorkspaceRoot, readChatSettings, updateChatSettings } from '../../shared/workspace.js';
+import { apiProcedure } from './trpc.js';
+import { createChatLogger } from '../agent/chat-logger.js';
+import { on } from 'node:events';
+import { daemonEvents, DAEMON_EVENT_MESSAGE_APPENDED } from '../events.js';
+import { createAgentSession } from '../agent/agent-session.js';
+import { executeSubagent, getSubagentDepth } from './subagent-utils.js';
+import type { SubagentTracker } from '../../shared/config.js';
+
+const MAX_SUBAGENT_DEPTH = 2;
+
+export const subagentSpawn = apiProcedure
+  .input(
+    z.object({
+      subagentId: z.string().optional(),
+      targetAgentId: z.string().optional(),
+      prompt: z.string(),
+      async: z.boolean().optional(),
+    })
+  )
+  .mutation(async ({ input, ctx }) => {
+    if (!ctx.tokenPayload) throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Missing token' });
+    const chatId = ctx.tokenPayload.chatId;
+    const parentAgentId = ctx.tokenPayload.agentId;
+    const parentId = ctx.tokenPayload.subagentId;
+
+    const id = input.subagentId || randomUUID();
+    const sessionId = randomUUID();
+    const agentId = input.targetAgentId || parentAgentId;
+    let depth = 0;
+
+    await updateChatSettings(chatId, (settings) => {
+      settings.subagents = settings.subagents || {};
+
+      depth = getSubagentDepth(settings, parentId);
+      if (depth >= MAX_SUBAGENT_DEPTH) {
+        throw new TRPCError({ code: 'BAD_REQUEST', message: 'Max subagent depth reached' });
+      }
+
+      // Make sure the id does not already exist
+      if (settings.subagents[id]) {
+        throw new TRPCError({ code: 'BAD_REQUEST', message: 'Subagent ID already exists' });
+      }
+
+      settings.subagents[id] = {
+        id,
+        agentId,
+        sessionId,
+        createdAt: new Date().toISOString(),
+        status: 'active',
+        parentId,
+      };
+
+      return settings;
+    });
+
+    const workspaceRoot = getWorkspaceRoot(process.cwd());
+
+    const isAsync = input.async ?? depth === 0;
+
+    // Execute asynchronously
+    executeSubagent(
+      chatId,
+      id,
+      agentId,
+      sessionId,
+      input.prompt,
+      isAsync,
+      ctx.tokenPayload,
+      workspaceRoot
+    );
+
+    return { id, depth, isAsync };
+  });
+
+export const subagentSend = apiProcedure
+  .input(
+    z.object({
+      subagentId: z.string(),
+      prompt: z.string(),
+      async: z.boolean().optional(),
+    })
+  )
+  .mutation(async ({ input, ctx }) => {
+    if (!ctx.tokenPayload) throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Missing token' });
+    const chatId = ctx.tokenPayload.chatId;
+
+    let sub: SubagentTracker | undefined;
+
+    await updateChatSettings(chatId, (settings) => {
+      if (!settings.subagents?.[input.subagentId]) {
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'Subagent not found' });
+      }
+
+      sub = settings.subagents[input.subagentId];
+      sub!.status = 'active';
+      return settings;
+    });
+
+    const workspaceRoot = getWorkspaceRoot(process.cwd());
+
+    // Execute asynchronously
+    executeSubagent(
+      chatId,
+      sub!.id,
+      sub!.agentId || 'default',
+      sub!.sessionId || 'default',
+      input.prompt,
+      input.async,
+      ctx.tokenPayload,
+      workspaceRoot
+    );
+
+    return { success: true };
+  });
+
+async function checkSubagentStatus(chatId: string, subagentId: string) {
+  const settings = await readChatSettings(chatId);
+  const sub = settings?.subagents?.[subagentId];
+  if (!sub) throw new TRPCError({ code: 'NOT_FOUND', message: 'Subagent not found' });
+
+  if (sub.status === 'completed' || sub.status === 'failed') {
+    let outputContent: string | undefined;
+    if (sub.status === 'completed') {
+      const logger = createChatLogger(chatId, subagentId);
+      const lastLogMessage = await logger.findLastMessage((m) => m.role === 'agent');
+      if (lastLogMessage && 'content' in lastLogMessage) {
+        outputContent = lastLogMessage.content;
+      }
+    }
+    return { status: sub.status, output: outputContent };
+  }
+  return null;
+}
+
+export const subagentWait = apiProcedure
+  .input(z.object({ subagentId: z.string() }))
+  .mutation(async ({ input, ctx, signal }) => {
+    if (!ctx.tokenPayload) throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Missing token' });
+    const chatId = ctx.tokenPayload.chatId;
+
+    const ac = new AbortController();
+    const timeout = setTimeout(() => ac.abort(), 60000);
+
+    // Bind to the TRPC request abort signal to clean up listeners if client disconnects
+    const onAbort = () => {
+      clearTimeout(timeout);
+      ac.abort();
+    };
+    if (signal) {
+      signal.addEventListener('abort', onAbort);
+    }
+
+    const eventIterator = on(daemonEvents, DAEMON_EVENT_MESSAGE_APPENDED, {
+      signal: ac.signal,
+    });
+
+    try {
+      // Check status immediately before listening, but after event iterator is buffering
+      const initialStatus = await checkSubagentStatus(chatId, input.subagentId);
+      if (initialStatus) {
+        clearTimeout(timeout);
+        if (signal) signal.removeEventListener('abort', onAbort);
+        return initialStatus;
+      }
+
+      for await (const [event] of eventIterator) {
+        if (event.chatId === chatId && event.message?.subagentId === input.subagentId) {
+          const msg = event.message;
+          if (msg.role === 'subagent_status') {
+            const status = await checkSubagentStatus(chatId, input.subagentId);
+            if (status) {
+              clearTimeout(timeout);
+              if (signal) signal.removeEventListener('abort', onAbort);
+              return status;
+            }
+          }
+        }
+      }
+    } catch (err: unknown) {
+      if (err && typeof err === 'object' && 'name' in err && err.name === 'AbortError') {
+        return { status: 'active' as const, output: undefined };
+      }
+      throw err;
+    } finally {
+      clearTimeout(timeout);
+      if (signal) signal.removeEventListener('abort', onAbort);
+      ac.abort();
+    }
+
+    return { status: 'active' as const, output: undefined };
+  });
+
+export const subagentStop = apiProcedure
+  .input(z.object({ subagentId: z.string() }))
+  .mutation(async ({ input, ctx }) => {
+    if (!ctx.tokenPayload) throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Missing token' });
+    const chatId = ctx.tokenPayload.chatId;
+
+    let subToStop: SubagentTracker | undefined;
+
+    await updateChatSettings(chatId, (settings) => {
+      if (settings.subagents) {
+        const sub = settings.subagents[input.subagentId];
+        if (sub) {
+          sub.status = 'failed';
+          subToStop = sub;
+        }
+      }
+      return settings;
+    });
+
+    if (subToStop) {
+      const session = await createAgentSession({
+        chatId,
+        agentId: subToStop.agentId || 'default',
+        sessionId: subToStop.sessionId || 'default',
+        subagentId: input.subagentId,
+        cwd: process.cwd(),
+      });
+      session.stop();
+    }
+
+    return { success: true };
+  });
+
+export const subagentDelete = apiProcedure
+  .input(z.object({ subagentId: z.string() }))
+  .mutation(async ({ input, ctx }) => {
+    if (!ctx.tokenPayload) throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Missing token' });
+    const chatId = ctx.tokenPayload.chatId;
+
+    let subToDelete: SubagentTracker | undefined;
+
+    await updateChatSettings(chatId, (settings) => {
+      if (settings.subagents && settings.subagents[input.subagentId]) {
+        subToDelete = settings.subagents[input.subagentId]!;
+        delete settings.subagents[input.subagentId];
+      }
+      return settings;
+    });
+
+    if (subToDelete) {
+      const session = await createAgentSession({
+        chatId,
+        agentId: subToDelete.agentId || 'default',
+        sessionId: subToDelete.sessionId || 'default',
+        subagentId: input.subagentId,
+        cwd: process.cwd(),
+      });
+      session.stop();
+
+      return { success: true, deleted: true };
+    }
+
+    return { success: true, deleted: false };
+  });
+
+export const subagentList = apiProcedure
+  .input(z.object({ blocking: z.boolean().optional() }).optional())
+  .query(async ({ input, ctx }) => {
+    if (!ctx.tokenPayload) throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Missing token' });
+    const chatId = ctx.tokenPayload.chatId;
+    const settings = await readChatSettings(chatId);
+
+    let subagents = Object.values(settings?.subagents || {});
+
+    const isSubagent = !!ctx.tokenPayload.subagentId;
+    const myId = ctx.tokenPayload.subagentId;
+
+    subagents = subagents.filter((s) => s.parentId === myId);
+
+    if (input?.blocking) {
+      if (!isSubagent) {
+        subagents = [];
+      } else {
+        subagents = subagents.filter((s) => s.status === 'active');
+      }
+    }
+    return { subagents };
+  });
+
+export const subagentTail = apiProcedure
+  .input(z.object({ subagentId: z.string(), limit: z.number().optional() }))
+  .query(async ({ input, ctx }) => {
+    if (!ctx.tokenPayload) throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Missing token' });
+    const chatId = ctx.tokenPayload.chatId;
+
+    const logger = createChatLogger(chatId, input.subagentId);
+    const messages = await logger.getMessages(input.limit);
+
+    return { messages };
+  });

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

@@ -0,0 +1,56 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { executeSubagent } from './subagent-utils.js';
+import * as workspace from '../../shared/workspace.js';
+import { taskScheduler } from '../agent/task-scheduler.js';
+
+vi.mock('../../shared/workspace.js', () => ({
+  updateChatSettings: vi.fn(),
+  readChatSettings: vi.fn().mockResolvedValue({}),
+}));
+
+vi.mock('../routers.js', () => ({
+  executeRouterPipeline: vi.fn().mockImplementation((state) => Promise.resolve(state)),
+  resolveRouters: vi.fn((routers) => routers),
+}));
+
+vi.mock('../message.js', () => ({
+  executeDirectMessage: vi.fn(),
+  applyRouterStateUpdates: vi.fn(),
+}));
+
+vi.mock('../agent/chat-logger.js', () => ({
+  createChatLogger: vi.fn(() => ({
+    findLastMessage: vi.fn().mockResolvedValue(null),
+    logSystemEvent: vi.fn(),
+  })),
+}));
+
+vi.mock('../agent/task-scheduler.js', () => ({
+  taskScheduler: {
+    hasTasks: vi.fn(),
+  },
+}));
+
+describe('executeSubagent', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should not mark subagent as completed if there are still pending tasks in the queue', async () => {
+    vi.mocked(taskScheduler.hasTasks).mockReturnValue(true);
+
+    await executeSubagent(
+      'chat-1',
+      'sub-1',
+      'agent-1',
+      'session-1',
+      'hello',
+      false,
+      { agentId: 'parent-agent' },
+      '/workspace'
+    );
+
+    // Should NOT call updateChatSettings to set status to completed
+    expect(workspace.updateChatSettings).not.toHaveBeenCalled();
+  });
+});

package/src/daemon/api/subagent-utils.ts

@@ -0,0 +1,130 @@
+import { randomUUID } from 'node:crypto';
+import { updateChatSettings, readChatSettings } from '../../shared/workspace.js';
+import { executeDirectMessage, applyRouterStateUpdates } from '../message.js';
+import { executeRouterPipeline, resolveRouters } from '../routers.js';
+import type { RouterState } from '../routers/types.js';
+import { createChatLogger } from '../agent/chat-logger.js';
+import type { ChatSettings } from '../../shared/config.js';
+import { taskScheduler } from '../agent/task-scheduler.js';
+
+export function getSubagentDepth(settings: ChatSettings, parentId: string | undefined): number {
+  let depth = 0;
+  let currentParentId = parentId;
+  while (currentParentId && settings.subagents?.[currentParentId]) {
+    depth++;
+    currentParentId = settings.subagents[currentParentId]?.parentId;
+  }
+  return depth;
+}
+
+export async function executeSubagent(
+  chatId: string,
+  subagentId: string,
+  agentId: string,
+  sessionId: string,
+  prompt: string,
+  isAsync: boolean | undefined,
+  parentTokenPayload: { agentId?: string; subagentId?: string; sessionId?: string },
+  workspaceRoot: string
+) {
+  try {
+    const settings = (await readChatSettings(chatId)) || {};
+    const routers = settings.routers ?? [];
+    const resolvedRouters = resolveRouters(routers, false);
+
+    let routerState: RouterState = {
+      messageId: randomUUID(),
+      message: prompt,
+      chatId,
+      agentId,
+      sessionId,
+      env: {},
+    };
+
+    const initialState = { ...routerState };
+    routerState = await executeRouterPipeline(routerState, resolvedRouters);
+
+    await applyRouterStateUpdates(
+      chatId,
+      workspaceRoot,
+      routerState,
+      settings,
+      initialState.agentId
+    );
+
+    await executeDirectMessage(
+      chatId,
+      routerState,
+      undefined, // settings
+      workspaceRoot,
+      false, // noWait
+      undefined, // userMessageContent
+      subagentId // subagentId
+    );
+
+    if (taskScheduler.hasTasks(sessionId)) {
+      return;
+    }
+
+    // Update status
+    await updateChatSettings(chatId, (finalSettings) => {
+      if (finalSettings.subagents?.[subagentId]) {
+        finalSettings.subagents[subagentId]!.status = 'completed';
+      }
+      return finalSettings;
+    });
+
+    const logger = createChatLogger(chatId, subagentId);
+
+    // Emit debug message to wake up waiters
+    await logger.logSubagentStatus({ subagentId, status: 'completed' });
+
+    if (isAsync) {
+      const lastLogMessage = await logger.findLastMessage(
+        (m) => m.role === 'agent' || m.displayRole === 'agent'
+      );
+      let outputContent = '';
+      if (lastLogMessage && 'content' in lastLogMessage) {
+        outputContent = `\n\n<subagent_output>\n${lastLogMessage.content}\n</subagent_output>`;
+      }
+
+      console.log(
+        'Notifying parent',
+        chatId,
+        parentTokenPayload?.agentId,
+        parentTokenPayload?.subagentId
+      );
+      // TODO: We need to overhaul the log system in general, and should not try to do it in this PR.
+      // Currently, if the parent is the root agent, this notification is logged as a normal user message
+      // and appears in the chat UI, violating the PRD requirement to hide orchestration.
+      await executeDirectMessage(
+        chatId,
+        {
+          messageId: randomUUID(),
+          message: `<notification>Subagent ${subagentId} completed.</notification>${outputContent}`,
+          chatId,
+          agentId: parentTokenPayload?.agentId || 'default',
+          ...(parentTokenPayload?.subagentId ? { subagentId: parentTokenPayload.subagentId } : {}),
+          sessionId: parentTokenPayload?.sessionId || 'default',
+          env: {},
+        },
+        undefined,
+        workspaceRoot,
+        true,
+        undefined,
+        parentTokenPayload?.subagentId,
+        'subagent_update'
+      );
+    }
+  } catch {
+    // TODO: Wrap this in a safe try-catch to prevent unhandled promise rejections crashing the daemon if disk errors occur
+    await updateChatSettings(chatId, (errSettings) => {
+      if (errSettings.subagents?.[subagentId]) {
+        errSettings.subagents[subagentId]!.status = 'failed';
+      }
+      return errSettings;
+    });
+    const logger = createChatLogger(chatId, subagentId);
+    await logger.logSubagentStatus({ subagentId, status: 'failed' });
+  }
+}

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

@@ -5,11 +5,16 @@ import { TRPCError } from '@trpc/server';
 import { pathIsInsideDir } from '../../shared/utils/fs.js';
 import { on } from 'node:events';
 import { daemonEvents, DAEMON_EVENT_MESSAGE_APPENDED, DAEMON_EVENT_TYPING } from '../events.js';
-import { getSettingsPath, readChatSettings, getWorkspaceRoot } from '../../shared/workspace.js';
+import {
+  getSettingsPath,
+  readChatSettings,
+  writeChatSettings,
+  getWorkspaceRoot,
+  listAgents,
+} from '../../shared/workspace.js';
 import { CronJobSchema } from '../../shared/config.js';
 import { handleUserMessage } from '../message.js';
-import { getDefaultChatId, getMessages as fetchMessages } from '../chats.js';
-import { runCommand } from '../utils/spawn.js';
+import { getDefaultChatId, getMessages as fetchMessages, listChats, createChat } from '../chats.js';
 import { apiProcedure, publicProcedure, router } from './trpc.js';
 import {
   getUniquePath,
@@ -94,16 +99,7 @@ export const sendMessage = apiProcedure
       message = message ? `${message}\n\n${fileList}` : fileList;
     }
 
-    await handleUserMessage(
-      chatId,
-      message,
-      settings,
-      undefined,
-      noWait,
-      (args) => runCommand({ ...args, logToTerminal: true }),
-      sessionId,
-      agentId
-    );
+    await handleUserMessage(chatId, message, settings, undefined, noWait, sessionId, agentId);
 
     return { success: true };
   });
@@ -192,6 +188,24 @@ export const userListCronJobs = apiProcedure
     return listCronJobsShared(chatId);
   });
 
+export const getChats = apiProcedure.query(async () => {
+  return listChats();
+});
+
+export const getAgents = apiProcedure.query(async () => {
+  return listAgents();
+});
+
+export const userCreateChat = apiProcedure
+  .input(z.object({ chatId: z.string(), agent: z.string().optional() }))
+  .mutation(async ({ input }) => {
+    await createChat(input.chatId);
+    if (input.agent) {
+      await writeChatSettings(input.chatId, { defaultAgent: input.agent });
+    }
+    return { success: true, chatId: input.chatId };
+  });
+
 export const userAddCronJob = apiProcedure
   .input(z.object({ chatId: z.string().optional(), job: CronJobSchema }))
   .mutation(async ({ input }) => {
@@ -216,6 +230,9 @@ export const userRouter = router({
   listCronJobs: userListCronJobs,
   addCronJob: userAddCronJob,
   deleteCronJob: userDeleteCronJob,
+  getChats,
+  getAgents,
+  createChat: userCreateChat,
 });
 
 export type UserRouter = typeof userRouter;

package/src/daemon/auth.ts

@@ -9,6 +9,7 @@ export interface TokenPayload {
   chatId: string;
   agentId: string;
   sessionId: string;
+  subagentId?: string;
   timestamp: number;
 }
 

package/src/daemon/chats.ts

@@ -14,12 +14,18 @@ export {
   type ChatMessage,
   type UserMessage,
   type CommandLogMessage,
+  type SystemMessage,
+  type AgentReplyMessage,
+  type ToolMessage,
+  type PolicyRequestMessage,
+  type SubagentStatusMessage,
   getChatsDir,
   isValidChatId,
   createChat,
   listChats,
   deleteChat,
   getMessages,
+  findLastMessage,
   getDefaultChatId,
   setDefaultChatId,
   DEFAULT_CHAT_ID,

package/src/daemon/cron.test.ts

@@ -1,7 +1,42 @@
-import { describe, it, expect } from 'vitest';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { CronManager } from './cron.js';
+// @ts-expect-error - node-schedule types are missing
+import schedule from 'node-schedule';
+import { getInitialRouterState } from './message.js';
+
+vi.mock('node-schedule', () => ({
+  default: {
+    scheduleJob: vi.fn(),
+  },
+}));
+
+vi.mock('./message.js', () => ({
+  getInitialRouterState: vi.fn().mockResolvedValue({}),
+  applyRouterStateUpdates: vi.fn(),
+  executeDirectMessage: vi.fn(),
+}));
+
+vi.mock('../shared/workspace.js', () => ({
+  readChatSettings: vi.fn().mockResolvedValue({}),
+  getSettingsPath: vi.fn().mockReturnValue('/mock/settings.json'),
+}));
+
+vi.mock('../shared/chats.js', () => ({
+  listChats: vi.fn().mockResolvedValue([]),
+}));
+
+vi.mock('node:fs/promises', () => ({
+  default: {
+    readFile: vi.fn().mockResolvedValue('{}'),
+  },
+}));
 
 describe('CronManager', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
   it('throws on invalid date in "at" schedule', () => {
     const cronManager = new CronManager();
     expect(() => {
@@ -25,4 +60,34 @@ describe('CronManager', () => {
       });
     }).not.toThrow();
   });
+
+  it('passes job.session.id to getInitialRouterState when session type is existing', async () => {
+    const cronManager = new CronManager();
+    let scheduledCallback: any = null;
+    vi.mocked(schedule.scheduleJob as any).mockImplementation((rule: any, cb: any) => {
+      scheduledCallback = cb;
+      return { cancel: vi.fn() } as any;
+    });
+
+    cronManager.scheduleJob('chat3', {
+      id: 'job3',
+      createdAt: new Date().toISOString(),
+      message: 'test existing session',
+      schedule: { at: '1m' },
+      session: { type: 'existing', id: 'my-old-session-id' },
+    });
+
+    expect(scheduledCallback).toBeTruthy();
+
+    // Execute the cron job callback
+    await scheduledCallback();
+
+    expect(getInitialRouterState).toHaveBeenCalledWith(
+      'chat3',
+      'test existing session',
+      expect.any(Object),
+      undefined,
+      'my-old-session-id'
+    );
+  });
 });