clawmini 0.0.2 → 0.0.3

package/src/daemon/{router.test.ts → api/index.test.ts}

@@ -1,10 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { appRouter } from './router.js';
-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 { userRouter, agentRouter } from './index.js';
+// No merged router to avoid duplicate key errors.
+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 * as fs from 'node:fs/promises';
 import path from 'node:path';
 
@@ -32,12 +34,16 @@ vi.mock('node:fs/promises', async (importOriginal) => {
   };
 });
 
-vi.mock('./message.js', () => ({
-  handleUserMessage: vi.fn(),
-}));
+vi.mock('../message.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../message.js')>();
+  return {
+    ...actual,
+    handleUserMessage: vi.fn(),
+  };
+});
 
-vi.mock('../shared/workspace.js', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('../shared/workspace.js')>();
+vi.mock('../../shared/workspace.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../../shared/workspace.js')>();
   return {
     ...actual,
     readChatSettings: vi.fn(),
@@ -46,14 +52,14 @@ vi.mock('../shared/workspace.js', async (importOriginal) => {
     getAgent: vi.fn(),
     getWorkspaceRoot: vi.fn().mockReturnValue(process.cwd()),
     getActiveEnvironmentName: vi.fn().mockResolvedValue(null),
-  getActiveEnvironmentInfo: vi.fn().mockResolvedValue(null),
+    getActiveEnvironmentInfo: vi.fn().mockResolvedValue(null),
     getEnvironmentPath: vi.fn().mockReturnValue(''),
     readEnvironment: vi.fn().mockResolvedValue(null),
   };
 });
 
-vi.mock('../shared/chats.js', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('../shared/chats.js')>();
+vi.mock('../../shared/chats.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../../shared/chats.js')>();
   return {
     ...actual,
     getDefaultChatId: vi.fn(),
@@ -77,7 +83,7 @@ describe('Daemon TRPC Router', () => {
       vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
       vi.mocked(workspace.readChatSettings).mockResolvedValue({});
 
-      const caller = appRouter.createCaller({});
+      const caller = userRouter.createCaller({});
       const jobs = await caller.listCronJobs({});
       expect(jobs).toEqual([]);
       expect(workspace.readChatSettings).toHaveBeenCalledWith('default-chat');
@@ -87,7 +93,7 @@ describe('Daemon TRPC Router', () => {
       vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
       vi.mocked(workspace.readChatSettings).mockResolvedValue({ jobs: [mockJob] });
 
-      const caller = appRouter.createCaller({});
+      const caller = userRouter.createCaller({});
       const jobs = await caller.listCronJobs({ chatId: 'custom-chat' });
       expect(jobs).toEqual([mockJob]);
       expect(workspace.readChatSettings).toHaveBeenCalledWith('custom-chat');
@@ -97,7 +103,7 @@ describe('Daemon TRPC Router', () => {
       vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
       vi.mocked(workspace.readChatSettings).mockResolvedValue({});
 
-      const caller = appRouter.createCaller({});
+      const caller = userRouter.createCaller({});
       const result = await caller.addCronJob({ job: mockJob });
 
       expect(result.success).toBe(true);
@@ -110,7 +116,7 @@ describe('Daemon TRPC Router', () => {
       vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
       vi.mocked(workspace.readChatSettings).mockResolvedValue({ jobs: [mockJob] });
 
-      const caller = appRouter.createCaller({});
+      const caller = userRouter.createCaller({});
       const updatedJob = { ...mockJob, message: 'updated' };
       const result = await caller.addCronJob({ job: updatedJob });
 
@@ -124,7 +130,7 @@ describe('Daemon TRPC Router', () => {
       vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
       vi.mocked(workspace.readChatSettings).mockResolvedValue({ jobs: [mockJob] });
 
-      const caller = appRouter.createCaller({});
+      const caller = userRouter.createCaller({});
       const result = await caller.deleteCronJob({ id: 'job-1' });
 
       expect(result.success).toBe(true);
@@ -136,7 +142,7 @@ describe('Daemon TRPC Router', () => {
       vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
       vi.mocked(workspace.readChatSettings).mockResolvedValue({ jobs: [mockJob] });
 
-      const caller = appRouter.createCaller({});
+      const caller = userRouter.createCaller({});
       const result = await caller.deleteCronJob({ id: 'non-existent' });
 
       expect(result.success).toBe(true);
@@ -150,7 +156,7 @@ describe('Daemon TRPC Router', () => {
       vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
       vi.mocked((fs as any).default.readFile).mockResolvedValue('{}');
 
-      const caller = appRouter.createCaller({});
+      const caller = userRouter.createCaller({});
       await caller.sendMessage({
         type: 'send-message',
         client: 'cli',
@@ -178,7 +184,7 @@ describe('Daemon TRPC Router', () => {
       vi.mocked((fs as any).default.rename).mockResolvedValue(undefined);
       vi.mocked((fs as any).default.access).mockResolvedValue(undefined);
 
-      const caller = appRouter.createCaller({});
+      const caller = userRouter.createCaller({});
       await caller.sendMessage({
         type: 'send-message',
         client: 'cli',
@@ -216,7 +222,7 @@ describe('Daemon TRPC Router', () => {
         .mockRejectedValue(new Error('not found'));
       vi.mocked((fs as any).default.rename).mockResolvedValue(undefined);
 
-      const caller = appRouter.createCaller({});
+      const caller = userRouter.createCaller({});
       await caller.sendMessage({
         type: 'send-message',
         client: 'cli',
@@ -243,7 +249,7 @@ describe('Daemon TRPC Router', () => {
       vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
       vi.mocked((fs as any).default.readFile).mockResolvedValue('{}');
 
-      const caller = appRouter.createCaller({});
+      const caller = userRouter.createCaller({});
       await expect(
         caller.sendMessage({
           type: 'send-message',
@@ -262,7 +268,7 @@ describe('Daemon TRPC Router', () => {
       vi.mocked((fs as any).default.readFile).mockResolvedValue('{}');
       vi.mocked((fs as any).default.access).mockRejectedValue(new Error('ENOENT'));
 
-      const caller = appRouter.createCaller({});
+      const caller = userRouter.createCaller({});
       await expect(
         caller.sendMessage({
           type: 'send-message',
@@ -282,9 +288,11 @@ describe('Daemon TRPC Router', () => {
       vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
       vi.mocked(chats.appendMessage).mockResolvedValue(undefined);
 
-      const caller = appRouter.createCaller({});
+      const caller = agentRouter.createCaller({
+        isApiServer: true,
+        tokenPayload: { agentId: 'default', chatId: 'default-chat' },
+      } as any);
       const result = await caller.logMessage({
-        chatId: 'default-chat',
         message: 'Test log',
       });
 
@@ -304,9 +312,11 @@ describe('Daemon TRPC Router', () => {
       vi.mocked(chats.appendMessage).mockResolvedValue(undefined);
       vi.mocked((fs as any).default.access).mockResolvedValue(undefined);
 
-      const caller = appRouter.createCaller({});
+      const caller = agentRouter.createCaller({
+        isApiServer: true,
+        tokenPayload: { agentId: 'default', chatId: 'default-chat' },
+      } as any);
       const result = await caller.logMessage({
-        chatId: 'default-chat',
         message: 'Test log with file',
         files: ['attachments/discord/image.png'],
       });
@@ -325,10 +335,12 @@ describe('Daemon TRPC Router', () => {
     it('should reject file path with directory traversal (..)', async () => {
       vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
 
-      const caller = appRouter.createCaller({});
+      const caller = agentRouter.createCaller({
+        isApiServer: true,
+        tokenPayload: { agentId: 'default', chatId: 'default-chat' },
+      } as any);
       await expect(
         caller.logMessage({
-          chatId: 'default-chat',
           message: 'Malicious log',
           files: ['../secret.txt'],
         })
@@ -338,10 +350,12 @@ describe('Daemon TRPC Router', () => {
     it('should reject file path with absolute path', async () => {
       vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
 
-      const caller = appRouter.createCaller({});
+      const caller = agentRouter.createCaller({
+        isApiServer: true,
+        tokenPayload: { agentId: 'default', chatId: 'default-chat' },
+      } as any);
       await expect(
         caller.logMessage({
-          chatId: 'default-chat',
           message: 'Malicious log',
           files: ['/etc/passwd'],
         })
@@ -353,7 +367,7 @@ describe('Daemon TRPC Router', () => {
     it('waitForTyping should yield typing events for the correct chatId', async () => {
       vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
 
-      const caller = appRouter.createCaller({});
+      const caller = userRouter.createCaller({});
       const iterable = await caller.waitForTyping({ chatId: 'default-chat' });
       const iterator = iterable[Symbol.asyncIterator]();
 
@@ -365,7 +379,7 @@ describe('Daemon TRPC Router', () => {
         if (e2.value) events.push(e2.value);
       })();
 
-      const { daemonEvents, DAEMON_EVENT_TYPING } = await import('./events.js');
+      const { daemonEvents, DAEMON_EVENT_TYPING } = await import('../events.js');
       await new Promise((resolve) => setTimeout(resolve, 10));
 
       daemonEvents.emit(DAEMON_EVENT_TYPING, { chatId: 'default-chat' });
@@ -377,4 +391,57 @@ describe('Daemon TRPC Router', () => {
       expect(events).toEqual([{ chatId: 'default-chat' }, { chatId: 'default-chat' }]);
     });
   });
+
+  describe('fetchPendingMessages', () => {
+    let queue: ReturnType<typeof getMessageQueue>;
+    beforeEach(() => {
+      queue = getMessageQueue(process.cwd());
+      queue.clear();
+    });
+
+    it('should extract pending messages from queue matching the session and format them', async () => {
+      let resolveFirstTask: () => void;
+      const firstTaskPromise = new Promise<void>((r) => {
+        resolveFirstTask = r;
+      });
+
+      // The first task will start and block, leaving the others in pending
+      queue.enqueue(
+        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' });
+
+      // We expect them to throw AbortError when extracted
+      p2.catch(() => {});
+      p3.catch(() => {});
+      p4.catch(() => {});
+
+      const caller = agentRouter.createCaller({
+        tokenPayload: { sessionId: 's1', chatId: 'c1', agentId: 'a1', timestamp: 123 },
+      });
+      const result = await caller.fetchPendingMessages();
+
+      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' },
+      ]);
+
+      resolveFirstTask!(); // cleanup
+    });
+
+    it('should return empty string if no pending messages', async () => {
+      const caller = agentRouter.createCaller({});
+      const result = await caller.fetchPendingMessages();
+      expect(result.messages).toBe('');
+    });
+  });
 });

package/src/daemon/api/index.ts

@@ -0,0 +1,4 @@
+export * from './trpc.js';
+export * from './router-utils.js';
+export * from './user-router.js';
+export * from './agent-router.js';

package/src/daemon/{router-policy-request.test.ts → api/policy-request.test.ts}

@@ -1,19 +1,19 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { appRouter } from './router.js';
-import * as chats from '../shared/chats.js';
+import { agentRouter as appRouter } from './index.js';
+import * as chats from '../../shared/chats.js';
 
-vi.mock('../shared/chats.js', () => ({
+vi.mock('../../shared/chats.js', () => ({
   getDefaultChatId: vi.fn().mockResolvedValue('default-chat'),
   appendMessage: vi.fn().mockResolvedValue(undefined),
 }));
 
-vi.mock('../shared/workspace.js', () => ({
+vi.mock('../../shared/workspace.js', () => ({
   getWorkspaceRoot: vi.fn().mockReturnValue('/mock/workspace'),
   getClawminiDir: vi.fn().mockReturnValue('/mock/.clawmini'),
 }));
 
-vi.mock('./policy-request-service.js', () => {
+vi.mock('../policy-request-service.js', () => {
   return {
     PolicyRequestService: class {
       async createRequest() {
@@ -39,12 +39,23 @@ const { mockReadFile } = vi.hoisted(() => {
   return { mockReadFile: vi.fn() };
 });
 
-vi.mock('node:fs/promises', () => ({
-  default: {
+vi.mock('node:fs/promises', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:fs/promises')>();
+  return {
+    ...actual,
+    default: {
+      ...actual,
+      readFile: mockReadFile,
+      mkdir: vi.fn(),
+      readdir: vi.fn().mockResolvedValue([]),
+      realpath: vi.fn().mockImplementation((p) => Promise.resolve(p)),
+    },
     readFile: mockReadFile,
-  },
-  readFile: mockReadFile,
-}));
+    mkdir: vi.fn(),
+    readdir: vi.fn().mockResolvedValue([]),
+    realpath: vi.fn().mockImplementation((p) => Promise.resolve(p)),
+  };
+});
 
 describe('createPolicyRequest preview message', () => {
   beforeEach(() => {
@@ -52,7 +63,10 @@ describe('createPolicyRequest preview message', () => {
   });
 
   it('should create a request and append a preview message truncating long files', async () => {
-    const caller = appRouter.createCaller({});
+    const caller = appRouter.createCaller({
+      isApiServer: true,
+      tokenPayload: { agentId: 'default', chatId: 'default-chat' },
+    } as any);
 
     // file1 is short, file2 is long
     const shortContent = 'Hello world!';
@@ -68,8 +82,8 @@ describe('createPolicyRequest preview message', () => {
       commandName: 'test-cmd',
       args: ['arg1', 'arg2'],
       fileMappings: {
-        file1: '/some/path1',
-        file2: '/some/path2',
+        file1: '/mock/workspace/file1',
+        file2: '/mock/workspace/file2',
       },
     });
 

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

@@ -0,0 +1,159 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { TRPCError } from '@trpc/server';
+import { pathIsInsideDir } from '../../shared/utils/fs.js';
+import {
+  getAgent,
+  getClawminiDir,
+  readChatSettings,
+  writeChatSettings,
+} from '../../shared/workspace.js';
+import { cronManager } from '../cron.js';
+import type { z } from 'zod';
+import type { CronJobSchema } from '../../shared/config.js';
+
+export async function getUniquePath(p: string): Promise<string> {
+  let currentPath = p;
+  let counter = 1;
+  while (true) {
+    try {
+      await fs.stat(currentPath);
+      const ext = path.extname(p);
+      const base = path.basename(p, ext);
+      currentPath = path.join(path.dirname(p), `${base}-${counter}${ext}`);
+      counter++;
+    } catch {
+      return currentPath;
+    }
+  }
+}
+
+export async function resolveAgentDir(
+  agentId: string | undefined | null,
+  workspaceRoot: string
+): Promise<string> {
+  if (agentId && agentId !== 'default') {
+    try {
+      const agent = await getAgent(agentId, workspaceRoot);
+      if (agent && agent.directory) {
+        return path.resolve(workspaceRoot, agent.directory);
+      }
+    } catch (err: unknown) {
+      console.warn(`Could not load custom agent '${agentId}' for resolving directory:`, err);
+    }
+    return path.resolve(workspaceRoot, agentId);
+  }
+  return workspaceRoot;
+}
+
+export async function getAgentFilesDir(
+  agentId: string | undefined,
+  chatId: string,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  settings: any,
+  workspaceRoot: string
+): Promise<string> {
+  const chatSettings = (await readChatSettings(chatId)) ?? {};
+  const targetAgentId = agentId ?? chatSettings.defaultAgent ?? 'default';
+  let agentFilesDir = settings?.defaultAgent?.files || './attachments';
+  const agentDir = await resolveAgentDir(targetAgentId, workspaceRoot);
+
+  if (targetAgentId !== 'default') {
+    try {
+      const customAgent = await getAgent(targetAgentId, workspaceRoot);
+      if (customAgent?.files) {
+        agentFilesDir = customAgent.files;
+      }
+    } catch (err: unknown) {
+      console.warn(
+        `Could not load custom agent '${targetAgentId}' for resolving files directory:`,
+        err
+      );
+    }
+  }
+
+  return path.resolve(agentDir, agentFilesDir);
+}
+
+export async function validateAttachments(files: string[]): Promise<void> {
+  const tmpDir = path.join(getClawminiDir(process.cwd()), 'tmp');
+
+  for (const file of files) {
+    const absoluteFile = path.resolve(process.cwd(), file);
+    if (!pathIsInsideDir(absoluteFile, tmpDir)) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: 'File must be inside the temporary directory.',
+      });
+    }
+    try {
+      await fs.access(absoluteFile);
+    } catch {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: `File does not exist: ${file}`,
+      });
+    }
+  }
+}
+
+export async function validateLogFile(
+  file: string,
+  agentDir: string,
+  workspaceRoot: string
+): Promise<string> {
+  const resolvedPath = path.resolve(agentDir, file);
+
+  if (!pathIsInsideDir(resolvedPath, agentDir, { allowSameDir: true })) {
+    throw new TRPCError({
+      code: 'BAD_REQUEST',
+      message: 'File must be within the agent workspace.',
+    });
+  }
+
+  try {
+    await fs.access(resolvedPath);
+  } catch {
+    throw new TRPCError({
+      code: 'BAD_REQUEST',
+      message: `File does not exist: ${file}`,
+    });
+  }
+
+  return path.relative(workspaceRoot, resolvedPath);
+}
+
+export async function listCronJobsShared(chatId: string) {
+  const settings = await readChatSettings(chatId);
+  return settings?.jobs ?? [];
+}
+
+export async function addCronJobShared(chatId: string, job: z.infer<typeof CronJobSchema>) {
+  const settings = (await readChatSettings(chatId)) || {};
+  const cronJobs = settings.jobs ?? [];
+  const existingIndex = cronJobs.findIndex((j) => j.id === job.id);
+  if (existingIndex >= 0) {
+    cronJobs[existingIndex] = job;
+  } else {
+    cronJobs.push(job);
+  }
+  settings.jobs = cronJobs;
+  await writeChatSettings(chatId, settings);
+  cronManager.scheduleJob(chatId, job);
+  return { success: true };
+}
+
+export async function deleteCronJobShared(chatId: string, id: string) {
+  const settings = await readChatSettings(chatId);
+  if (!settings || !settings.jobs) {
+    return { success: true, deleted: false };
+  }
+  const initialLength = settings.jobs.length;
+  settings.jobs = settings.jobs.filter((j) => j.id !== id);
+  if (settings.jobs.length !== initialLength) {
+    await writeChatSettings(chatId, settings);
+    cronManager.unscheduleJob(chatId, id);
+    return { success: true, deleted: true };
+  }
+  return { success: true, deleted: false };
+}

package/src/daemon/api/trpc.ts

@@ -0,0 +1,30 @@
+import { initTRPC, TRPCError } from '@trpc/server';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { TokenPayload } from '../auth.js';
+
+export interface Context {
+  req?: IncomingMessage | undefined;
+  res?: ServerResponse | undefined;
+  isApiServer?: boolean | undefined;
+  tokenPayload?: TokenPayload | null | undefined;
+}
+
+const t = initTRPC.context<Context>().create();
+export const router = t.router;
+export const publicProcedure = t.procedure;
+
+const apiAuthMiddleware = t.middleware(({ ctx, next }) => {
+  if (ctx.isApiServer) {
+    if (!ctx.tokenPayload) {
+      throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Missing or invalid token' });
+    }
+  }
+  return next({
+    ctx: {
+      ...ctx,
+      tokenPayload: ctx.tokenPayload,
+    },
+  });
+});
+
+export const apiProcedure = t.procedure.use(apiAuthMiddleware);