clawmini 0.0.1

package/src/daemon/request-store.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { RequestStore } from './request-store.js';
+import type { PolicyRequest } from '../shared/policies.js';
+import fs from 'fs/promises';
+import path from 'path';
+import * as workspace from '../shared/workspace.js';
+
+vi.mock('../shared/workspace.js', () => ({
+  getClawminiDir: vi.fn(),
+}));
+
+describe('RequestStore', () => {
+  const TEST_DIR = path.join(process.cwd(), '.test-requests');
+  let store: RequestStore;
+
+  beforeEach(async () => {
+    vi.mocked(workspace.getClawminiDir).mockReturnValue(TEST_DIR);
+    store = new RequestStore();
+    await fs.rm(TEST_DIR, { recursive: true, force: true });
+    await fs.mkdir(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(TEST_DIR, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it('should save and load a request', async () => {
+    const req: PolicyRequest = {
+      id: 'req-123',
+      commandName: 'test-cmd',
+      args: ['arg1'],
+      fileMappings: {},
+      state: 'Pending',
+      createdAt: Date.now(),
+      chatId: 'chat-1',
+      agentId: 'agent-1',
+    };
+
+    await store.save(req);
+    const loaded = await store.load('req-123');
+    expect(loaded).toEqual(req);
+  });
+
+  it('should return null for non-existent request', async () => {
+    const loaded = await store.load('missing-req');
+    expect(loaded).toBeNull();
+  });
+
+  it('should list requests sorted by createdAt descending', async () => {
+    const req1: PolicyRequest = {
+      id: 'req-1',
+      commandName: 'cmd1',
+      args: [],
+      fileMappings: {},
+      state: 'Pending',
+      createdAt: 1000,
+      chatId: 'chat-1',
+      agentId: 'agent-1',
+    };
+    const req2: PolicyRequest = {
+      id: 'req-2',
+      commandName: 'cmd2',
+      args: [],
+      fileMappings: {},
+      state: 'Pending',
+      createdAt: 2000,
+      chatId: 'chat-2',
+      agentId: 'agent-2',
+    };
+
+    await store.save(req1);
+    await store.save(req2);
+
+    const list = await store.list();
+    expect(list).toHaveLength(2);
+    expect(list[0]?.id).toBe('req-2');
+    expect(list[1]?.id).toBe('req-1');
+  });
+
+  it('should gracefully handle corrupted files during load', async () => {
+    const req: PolicyRequest = {
+      id: 'req-good',
+      commandName: 'cmd',
+      args: [],
+      fileMappings: {},
+      state: 'Pending',
+      createdAt: 1000,
+      chatId: 'chat-1',
+      agentId: 'agent-1',
+    };
+    await store.save(req);
+
+    await fs.writeFile(path.join(TEST_DIR, 'tmp', 'requests', 'req-corrupt.json'), 'invalid json');
+
+    const loadedCorrupt = await store.load('req-corrupt');
+    expect(loadedCorrupt).toBeNull();
+
+    const list = await store.list();
+    expect(list).toHaveLength(1);
+    expect(list[0]?.id).toBe('req-good');
+  });
+});

package/src/daemon/request-store.ts

@@ -0,0 +1,96 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { z } from 'zod';
+import { getClawminiDir } from '../shared/workspace.js';
+import type { PolicyRequest } from '../shared/policies.js';
+import { randomInt } from 'crypto';
+
+const PolicyRequestSchema = z.object({
+  id: z.string(),
+  commandName: z.string(),
+  args: z.array(z.string()),
+  fileMappings: z.record(z.string(), z.string()),
+  state: z.enum(['Pending', 'Approved', 'Rejected']),
+  createdAt: z.number(),
+  rejectionReason: z.string().optional(),
+  chatId: z.string(),
+  agentId: z.string(),
+});
+
+function isENOENT(err: unknown): boolean {
+  return Boolean(
+    err && typeof err === 'object' && 'code' in err && (err as { code: string }).code === 'ENOENT'
+  );
+}
+
+export class RequestStore {
+  private baseDir: string;
+
+  constructor(startDir = process.cwd()) {
+    this.baseDir = path.join(getClawminiDir(startDir), 'tmp', 'requests');
+  }
+
+  async init(): Promise<void> {
+    await fs.mkdir(this.baseDir, { recursive: true });
+  }
+
+  private getFilePath(id: string): string {
+    return path.join(this.baseDir, `${id}.json`);
+  }
+
+  async save(request: PolicyRequest): Promise<void> {
+    await this.init();
+    const filePath = this.getFilePath(request.id);
+    await fs.writeFile(filePath, JSON.stringify(request, null, 2), 'utf8');
+  }
+
+  async load(id: string): Promise<PolicyRequest | null> {
+    const normalizedId = normalizePolicyId(id);
+    const filePath = this.getFilePath(normalizedId);
+    try {
+      const data = await fs.readFile(filePath, 'utf8');
+      return PolicyRequestSchema.parse(JSON.parse(data)) as PolicyRequest;
+    } catch (err: unknown) {
+      if (isENOENT(err)) {
+        return null;
+      }
+      const msg = err instanceof Error ? err.message : String(err);
+      console.warn(`Failed to parse request file ${filePath}:`, msg);
+      return null;
+    }
+  }
+
+  async list(): Promise<PolicyRequest[]> {
+    await this.init();
+    const requests: PolicyRequest[] = [];
+    try {
+      const files = await fs.readdir(this.baseDir);
+      for (const file of files) {
+        if (!file.endsWith('.json')) continue;
+        const id = path.basename(file, '.json');
+        const req = await this.load(id);
+        if (req) {
+          requests.push(req);
+        }
+      }
+    } catch (err: unknown) {
+      if (!isENOENT(err)) {
+        throw err;
+      }
+    }
+    return requests.sort((a, b) => b.createdAt - a.createdAt);
+  }
+}
+
+export function generateRandomAlphaNumericString(length: number): string {
+  const characters = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+  let result = '';
+  for (let i = 0; i < length; i++) {
+    result += characters[Math.floor(randomInt(characters.length))];
+  }
+  return result;
+}
+
+function normalizePolicyId(id: string): string {
+  return id.toLocaleUpperCase().trim();
+}

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

@@ -0,0 +1,99 @@
+/* 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';
+
+vi.mock('../shared/chats.js', () => ({
+  getDefaultChatId: vi.fn().mockResolvedValue('default-chat'),
+  appendMessage: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock('../shared/workspace.js', () => ({
+  getWorkspaceRoot: vi.fn().mockReturnValue('/mock/workspace'),
+  getClawminiDir: vi.fn().mockReturnValue('/mock/.clawmini'),
+}));
+
+vi.mock('./policy-request-service.js', () => {
+  return {
+    PolicyRequestService: class {
+      async createRequest() {
+        return {
+          id: 'req-123',
+          commandName: 'test-cmd',
+          args: ['arg1', 'arg2'],
+          fileMappings: {
+            file1: '/mock/.clawmini/tmp/snapshots/file1.txt',
+            file2: '/mock/.clawmini/tmp/snapshots/file2.txt',
+          },
+          state: 'Pending',
+          createdAt: Date.now(),
+          chatId: 'chat-1',
+          agentId: 'agent-1',
+        };
+      }
+    },
+  };
+});
+
+const { mockReadFile } = vi.hoisted(() => {
+  return { mockReadFile: vi.fn() };
+});
+
+vi.mock('node:fs/promises', () => ({
+  default: {
+    readFile: mockReadFile,
+  },
+  readFile: mockReadFile,
+}));
+
+describe('createPolicyRequest preview message', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should create a request and append a preview message truncating long files', async () => {
+    const caller = appRouter.createCaller({});
+
+    // file1 is short, file2 is long
+    const shortContent = 'Hello world!';
+    const longContent = 'A'.repeat(600);
+
+    mockReadFile.mockImplementation(async (filePath: any) => {
+      if (filePath.toString().includes('file1')) return shortContent;
+      if (filePath.toString().includes('file2')) return longContent;
+      return '';
+    });
+
+    const result = await caller.createPolicyRequest({
+      commandName: 'test-cmd',
+      args: ['arg1', 'arg2'],
+      fileMappings: {
+        file1: '/some/path1',
+        file2: '/some/path2',
+      },
+    });
+
+    expect(result.id).toBe('req-123');
+
+    expect(chats.appendMessage).toHaveBeenCalledTimes(1);
+    const callArgs = vi.mocked(chats.appendMessage).mock.calls[0]!;
+    const chatId = callArgs[0];
+    const logMsg = callArgs[1] as any;
+
+    expect(chatId).toBe('default-chat');
+    expect(logMsg.role).toBe('log');
+    expect(logMsg.command).toBe('policy-request');
+
+    // Assert preview content format
+    const content = logMsg.content;
+    expect(content).toContain('Sandbox Policy Request: test-cmd');
+    expect(content).toContain('ID: req-123');
+    expect(content).toContain('Args: arg1 arg2');
+
+    expect(content).toContain('File [file1]:\n' + shortContent);
+
+    // The long file should be truncated to 500 chars + suffix
+    expect(content).toContain('File [file2]:\n' + 'A'.repeat(500) + '\n... (truncated)');
+    expect(content).toContain('Use /approve req-123 or /reject req-123 [reason]');
+  });
+});

package/src/daemon/router.test.ts

@@ -0,0 +1,380 @@
+/* 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 * as fs from 'node:fs/promises';
+import path from 'node:path';
+
+vi.mock('node:fs/promises', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:fs/promises')>();
+  return {
+    ...actual,
+    default: {
+      ...actual,
+      readFile: vi.fn(),
+      mkdir: vi.fn(),
+      stat: vi.fn(),
+      rename: vi.fn(),
+      copyFile: vi.fn(),
+      unlink: vi.fn(),
+      access: vi.fn(),
+    },
+    readFile: vi.fn(),
+    mkdir: vi.fn(),
+    stat: vi.fn(),
+    rename: vi.fn(),
+    copyFile: vi.fn(),
+    unlink: vi.fn(),
+    access: vi.fn(),
+  };
+});
+
+vi.mock('./message.js', () => ({
+  handleUserMessage: vi.fn(),
+}));
+
+vi.mock('../shared/workspace.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../shared/workspace.js')>();
+  return {
+    ...actual,
+    readChatSettings: vi.fn(),
+    writeChatSettings: vi.fn(),
+    getSettingsPath: vi.fn().mockReturnValue('/mock/settings.json'),
+    getAgent: vi.fn(),
+    getWorkspaceRoot: vi.fn().mockReturnValue(process.cwd()),
+    getActiveEnvironmentName: 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')>();
+  return {
+    ...actual,
+    getDefaultChatId: vi.fn(),
+    appendMessage: vi.fn(),
+  };
+});
+
+describe('Daemon TRPC Router', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('Cron Jobs Endpoints', () => {
+    const mockJob: CronJob = {
+      id: 'job-1',
+      message: 'test message',
+      schedule: { cron: '* * * * *' },
+    };
+
+    it('listCronJobs should return empty array if no jobs exist', async () => {
+      vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
+      vi.mocked(workspace.readChatSettings).mockResolvedValue({});
+
+      const caller = appRouter.createCaller({});
+      const jobs = await caller.listCronJobs({});
+      expect(jobs).toEqual([]);
+      expect(workspace.readChatSettings).toHaveBeenCalledWith('default-chat');
+    });
+
+    it('listCronJobs should return existing jobs', async () => {
+      vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
+      vi.mocked(workspace.readChatSettings).mockResolvedValue({ jobs: [mockJob] });
+
+      const caller = appRouter.createCaller({});
+      const jobs = await caller.listCronJobs({ chatId: 'custom-chat' });
+      expect(jobs).toEqual([mockJob]);
+      expect(workspace.readChatSettings).toHaveBeenCalledWith('custom-chat');
+    });
+
+    it('addCronJob should add a new job', async () => {
+      vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
+      vi.mocked(workspace.readChatSettings).mockResolvedValue({});
+
+      const caller = appRouter.createCaller({});
+      const result = await caller.addCronJob({ job: mockJob });
+
+      expect(result.success).toBe(true);
+      expect(workspace.writeChatSettings).toHaveBeenCalledWith('default-chat', {
+        jobs: [mockJob],
+      });
+    });
+
+    it('addCronJob should update an existing job', async () => {
+      vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
+      vi.mocked(workspace.readChatSettings).mockResolvedValue({ jobs: [mockJob] });
+
+      const caller = appRouter.createCaller({});
+      const updatedJob = { ...mockJob, message: 'updated' };
+      const result = await caller.addCronJob({ job: updatedJob });
+
+      expect(result.success).toBe(true);
+      expect(workspace.writeChatSettings).toHaveBeenCalledWith('default-chat', {
+        jobs: [updatedJob],
+      });
+    });
+
+    it('deleteCronJob should delete an existing job', async () => {
+      vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
+      vi.mocked(workspace.readChatSettings).mockResolvedValue({ jobs: [mockJob] });
+
+      const caller = appRouter.createCaller({});
+      const result = await caller.deleteCronJob({ id: 'job-1' });
+
+      expect(result.success).toBe(true);
+      expect(result.deleted).toBe(true);
+      expect(workspace.writeChatSettings).toHaveBeenCalledWith('default-chat', { jobs: [] });
+    });
+
+    it('deleteCronJob should return deleted: false if job not found', async () => {
+      vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
+      vi.mocked(workspace.readChatSettings).mockResolvedValue({ jobs: [mockJob] });
+
+      const caller = appRouter.createCaller({});
+      const result = await caller.deleteCronJob({ id: 'non-existent' });
+
+      expect(result.success).toBe(true);
+      expect(result.deleted).toBe(false);
+      expect(workspace.writeChatSettings).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('sendMessage with files processing', () => {
+    it('should pass message through when no files are provided', async () => {
+      vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
+      vi.mocked((fs as any).default.readFile).mockResolvedValue('{}');
+
+      const caller = appRouter.createCaller({});
+      await caller.sendMessage({
+        type: 'send-message',
+        client: 'cli',
+        data: { message: 'hello', chatId: 'default-chat' },
+      });
+
+      expect(message.handleUserMessage).toHaveBeenCalledWith(
+        'default-chat',
+        'hello',
+        {},
+        undefined,
+        false,
+        expect.any(Function),
+        undefined,
+        undefined
+      );
+      expect((fs as any).default.mkdir).not.toHaveBeenCalled();
+    });
+
+    it('should process files and format message correctly', async () => {
+      vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
+      vi.mocked((fs as any).default.readFile).mockResolvedValue('{}');
+      vi.mocked(workspace.readChatSettings).mockResolvedValue({ defaultAgent: 'default' });
+      vi.mocked((fs as any).default.stat).mockRejectedValue(new Error('not found')); // Files do not exist (no collision)
+      vi.mocked((fs as any).default.rename).mockResolvedValue(undefined);
+      vi.mocked((fs as any).default.access).mockResolvedValue(undefined);
+
+      const caller = appRouter.createCaller({});
+      await caller.sendMessage({
+        type: 'send-message',
+        client: 'cli',
+        data: {
+          message: 'hello',
+          chatId: 'default-chat',
+          files: ['.clawmini/tmp/file1.txt', '.clawmini/tmp/file2.png'],
+          adapter: 'discord',
+        },
+      });
+
+      expect((fs as any).default.mkdir).toHaveBeenCalledWith(
+        expect.stringContaining(path.join('attachments', 'discord')),
+        { recursive: true }
+      );
+      expect((fs as any).default.rename).toHaveBeenCalledTimes(2);
+
+      const handleUserMessageCall = vi.mocked(message.handleUserMessage).mock.calls[0];
+      expect(handleUserMessageCall).toBeDefined();
+      const formattedMessage = handleUserMessageCall![1];
+      expect(formattedMessage).toContain('Attached files:');
+      expect(formattedMessage).toContain('- ' + path.normalize('attachments/discord/file1.txt'));
+      expect(formattedMessage).toContain('- ' + path.normalize('attachments/discord/file2.png'));
+    });
+
+    it('should handle file collision by appending timestamp', async () => {
+      vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
+      vi.mocked((fs as any).default.readFile).mockResolvedValue('{}');
+      vi.mocked(workspace.readChatSettings).mockResolvedValue({ defaultAgent: 'default' });
+      vi.mocked((fs as any).default.access).mockResolvedValue(undefined);
+
+      // Simulate file already exists for collision
+      vi.mocked((fs as any).default.stat)
+        .mockResolvedValueOnce({} as import('node:fs').Stats)
+        .mockRejectedValue(new Error('not found'));
+      vi.mocked((fs as any).default.rename).mockResolvedValue(undefined);
+
+      const caller = appRouter.createCaller({});
+      await caller.sendMessage({
+        type: 'send-message',
+        client: 'cli',
+        data: {
+          message: 'hello',
+          chatId: 'default-chat',
+          files: ['.clawmini/tmp/file1.txt'],
+          adapter: 'discord',
+        },
+      });
+
+      expect((fs as any).default.rename).toHaveBeenCalledWith(
+        '.clawmini/tmp/file1.txt',
+        expect.stringMatching(/file1-\d+\.txt$/)
+      );
+
+      const handleUserMessageCall = vi.mocked(message.handleUserMessage).mock.calls[0];
+      expect(handleUserMessageCall).toBeDefined();
+      const formattedMessage = handleUserMessageCall![1];
+      expect(formattedMessage).toMatch(/- .*file1-\d+\.txt/);
+    });
+
+    it('should reject file path outside .clawmini/tmp for sendMessage', async () => {
+      vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
+      vi.mocked((fs as any).default.readFile).mockResolvedValue('{}');
+
+      const caller = appRouter.createCaller({});
+      await expect(
+        caller.sendMessage({
+          type: 'send-message',
+          client: 'cli',
+          data: {
+            message: 'hello',
+            chatId: 'default-chat',
+            files: ['/etc/passwd'],
+          },
+        })
+      ).rejects.toThrow('File must be inside the temporary directory.');
+    });
+
+    it('should reject non-existent file for sendMessage', async () => {
+      vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
+      vi.mocked((fs as any).default.readFile).mockResolvedValue('{}');
+      vi.mocked((fs as any).default.access).mockRejectedValue(new Error('ENOENT'));
+
+      const caller = appRouter.createCaller({});
+      await expect(
+        caller.sendMessage({
+          type: 'send-message',
+          client: 'cli',
+          data: {
+            message: 'hello',
+            chatId: 'default-chat',
+            files: ['.clawmini/tmp/missing.txt'],
+          },
+        })
+      ).rejects.toThrow('File does not exist: .clawmini/tmp/missing.txt');
+    });
+  });
+
+  describe('logMessage', () => {
+    it('should save a log message without a file', async () => {
+      vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
+      vi.mocked(chats.appendMessage).mockResolvedValue(undefined);
+
+      const caller = appRouter.createCaller({});
+      const result = await caller.logMessage({
+        chatId: 'default-chat',
+        message: 'Test log',
+      });
+
+      expect(result.success).toBe(true);
+      expect(chats.appendMessage).toHaveBeenCalledWith(
+        'default-chat',
+        expect.objectContaining({
+          role: 'log',
+          content: 'Test log',
+        }),
+        expect.any(String)
+      );
+    });
+
+    it('should validate and save a log message with a valid file path', async () => {
+      vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
+      vi.mocked(chats.appendMessage).mockResolvedValue(undefined);
+      vi.mocked((fs as any).default.access).mockResolvedValue(undefined);
+
+      const caller = appRouter.createCaller({});
+      const result = await caller.logMessage({
+        chatId: 'default-chat',
+        message: 'Test log with file',
+        files: ['attachments/discord/image.png'],
+      });
+
+      expect(result.success).toBe(true);
+      expect(chats.appendMessage).toHaveBeenCalledWith(
+        'default-chat',
+        expect.objectContaining({
+          role: 'log',
+          content: 'Test log with file',
+          files: [path.normalize('attachments/discord/image.png')],
+        }),
+        expect.any(String)
+      );
+    });
+    it('should reject file path with directory traversal (..)', async () => {
+      vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
+
+      const caller = appRouter.createCaller({});
+      await expect(
+        caller.logMessage({
+          chatId: 'default-chat',
+          message: 'Malicious log',
+          files: ['../secret.txt'],
+        })
+      ).rejects.toThrow('File must be within the agent workspace.');
+    });
+
+    it('should reject file path with absolute path', async () => {
+      vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
+
+      const caller = appRouter.createCaller({});
+      await expect(
+        caller.logMessage({
+          chatId: 'default-chat',
+          message: 'Malicious log',
+          files: ['/etc/passwd'],
+        })
+      ).rejects.toThrow('File must be within the agent workspace.');
+    });
+  });
+
+  describe('Subscriptions', () => {
+    it('waitForTyping should yield typing events for the correct chatId', async () => {
+      vi.mocked(chats.getDefaultChatId).mockResolvedValue('default-chat');
+
+      const caller = appRouter.createCaller({});
+      const iterable = await caller.waitForTyping({ chatId: 'default-chat' });
+      const iterator = iterable[Symbol.asyncIterator]();
+
+      const events: any[] = [];
+      const iteratePromise = (async () => {
+        const e1 = await iterator.next();
+        if (e1.value) events.push(e1.value);
+        const e2 = await iterator.next();
+        if (e2.value) events.push(e2.value);
+      })();
+
+      const { daemonEvents, DAEMON_EVENT_TYPING } = await import('./events.js');
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      daemonEvents.emit(DAEMON_EVENT_TYPING, { chatId: 'default-chat' });
+      daemonEvents.emit(DAEMON_EVENT_TYPING, { chatId: 'other-chat' });
+      daemonEvents.emit(DAEMON_EVENT_TYPING, { chatId: 'default-chat' });
+
+      await iteratePromise;
+
+      expect(events).toEqual([{ chatId: 'default-chat' }, { chatId: 'default-chat' }]);
+    });
+  });
+});