clawmini 0.0.1

package/src/daemon/message-queue.test.ts

@@ -0,0 +1,143 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { handleUserMessage } from './message.js';
+import * as chats from './chats.js';
+import { spawn } from 'node:child_process';
+import { runCommandCallback, createMockSpawn } from './message-test-utils.js';
+
+vi.mock('node:child_process', () => ({ spawn: vi.fn() }));
+vi.mock('./chats.js', () => ({ appendMessage: vi.fn().mockResolvedValue(undefined) }));
+vi.mock('./routers.js', () => ({
+  executeRouterPipeline: vi.fn().mockImplementation((state) => Promise.resolve(state)),
+}));
+vi.mock('../shared/workspace.js', () => ({
+  readChatSettings: vi.fn().mockResolvedValue(null),
+  writeChatSettings: vi.fn().mockResolvedValue(undefined),
+  readAgentSessionSettings: vi.fn().mockResolvedValue(null),
+  writeAgentSessionSettings: vi.fn().mockResolvedValue(undefined),
+  getAgent: vi.fn().mockResolvedValue(null),
+  getWorkspaceRoot: vi.fn().mockImplementation((cwd) => cwd),
+  getActiveEnvironmentName: vi.fn().mockResolvedValue(null),
+  getActiveEnvironmentInfo: vi.fn().mockResolvedValue(null),
+  getEnvironmentPath: vi.fn().mockReturnValue(''),
+  readEnvironment: vi.fn().mockResolvedValue(null),
+}));
+
+describe('Daemon Execution Queue', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('runs sequentially for the same directory', async () => {
+    const mockSpawn = createMockSpawn();
+    (spawn as any).mockImplementation(mockSpawn);
+
+    const settings = { defaultAgent: { commands: { new: 'echo msg' } } };
+
+    const p1 = handleUserMessage(
+      'chat1',
+      'msg1',
+      settings as any,
+      '/dir1',
+      false,
+      runCommandCallback
+    );
+
+    await new Promise((r) => setTimeout(r, 0));
+
+    const emitter1 = (mockSpawn as any).lastEmitter;
+    expect(mockSpawn).toHaveBeenCalledTimes(1);
+
+    const p2 = handleUserMessage(
+      'chat1',
+      'msg2',
+      settings as any,
+      '/dir1',
+      false,
+      runCommandCallback
+    );
+
+    await new Promise((r) => setTimeout(r, 0));
+
+    // spawn should still be 1 because p2 is queued
+    expect(mockSpawn).toHaveBeenCalledTimes(1);
+
+    // finish process 1
+    emitter1.finish(0);
+    await p1;
+
+    // wait a tick for p2 to start
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(mockSpawn).toHaveBeenCalledTimes(2);
+    const emitter2 = (mockSpawn as any).lastEmitter;
+
+    emitter2.finish(0);
+    await p2;
+
+    expect(chats.appendMessage).toHaveBeenCalled();
+  });
+
+  it('runs concurrently for different directories', async () => {
+    const mockSpawn = createMockSpawn();
+    (spawn as any).mockImplementation(mockSpawn);
+
+    const settings = { defaultAgent: { commands: { new: 'echo msg' } } };
+
+    handleUserMessage('chat1', 'msg1', settings as any, '/dir1', false, runCommandCallback);
+    await new Promise((r) => setTimeout(r, 0));
+    expect(mockSpawn).toHaveBeenCalledTimes(1);
+
+    handleUserMessage('chat1', 'msg2', settings as any, '/dir2', false, runCommandCallback);
+    await new Promise((r) => setTimeout(r, 0));
+
+    // Since it's a different directory, it should spawn immediately
+    expect(mockSpawn).toHaveBeenCalledTimes(2);
+  });
+
+  it('records failure logs without halting the queue', async () => {
+    const mockSpawn = createMockSpawn();
+    (spawn as any).mockImplementation(mockSpawn);
+
+    const settings = { defaultAgent: { commands: { new: 'echo msg' } } };
+
+    const p1 = handleUserMessage(
+      'chat1',
+      'msg1',
+      settings as any,
+      '/dir-fail',
+      false,
+      runCommandCallback
+    );
+    await new Promise((r) => setTimeout(r, 0));
+
+    const p2 = handleUserMessage(
+      'chat1',
+      'msg2',
+      settings as any,
+      '/dir-fail',
+      false,
+      runCommandCallback
+    );
+
+    const emitter1 = (mockSpawn as any).emitters[0];
+    emitter1.fail(new Error('command not found'));
+    await p1;
+
+    expect(chats.appendMessage).toHaveBeenCalledWith(
+      'chat1',
+      expect.objectContaining({
+        role: 'log',
+        exitCode: 1,
+        stderr: 'Error: command not found',
+      })
+    );
+
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(mockSpawn).toHaveBeenCalledTimes(2);
+    const emitter2 = (mockSpawn as any).emitters[1];
+    emitter2.finish(0);
+    await p2;
+  });
+});

package/src/daemon/message-router.test.ts

@@ -0,0 +1,106 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { handleUserMessage } from './message.js';
+import * as workspace from '../shared/workspace.js';
+import * as chats from './chats.js';
+import { executeRouterPipeline } from './routers.js';
+import { spawn } from 'node:child_process';
+import { runCommandCallback, createAutoFinishMockSpawn } from './message-test-utils.js';
+
+vi.mock('node:child_process', () => ({ spawn: vi.fn() }));
+vi.mock('./chats.js', () => ({ appendMessage: vi.fn().mockResolvedValue(undefined) }));
+vi.mock('./routers.js', () => ({
+  executeRouterPipeline: vi.fn().mockImplementation((state) => Promise.resolve(state)),
+}));
+vi.mock('../shared/workspace.js', () => ({
+  readChatSettings: vi.fn().mockResolvedValue(null),
+  writeChatSettings: vi.fn().mockResolvedValue(undefined),
+  readAgentSessionSettings: vi.fn().mockResolvedValue(null),
+  writeAgentSessionSettings: vi.fn().mockResolvedValue(undefined),
+  getAgent: vi.fn().mockResolvedValue(null),
+  getWorkspaceRoot: vi.fn().mockImplementation((cwd) => cwd),
+  getActiveEnvironmentName: vi.fn().mockResolvedValue(null),
+  getActiveEnvironmentInfo: vi.fn().mockResolvedValue(null),
+  getEnvironmentPath: vi.fn().mockReturnValue(''),
+  readEnvironment: vi.fn().mockResolvedValue(null),
+}));
+
+describe('Router Pipeline Execution', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('applies updated state properties to the queue', async () => {
+    const mockSpawn = createAutoFinishMockSpawn();
+    (spawn as any).mockImplementation(mockSpawn);
+
+    vi.mocked(workspace.readChatSettings).mockResolvedValue({
+      defaultAgent: 'old-agent',
+      routers: ['@clawmini/slash-new'],
+    });
+    vi.mocked(workspace.readAgentSessionSettings).mockResolvedValue(null);
+    vi.mocked(workspace.getAgent).mockResolvedValue(null);
+
+    vi.mocked(executeRouterPipeline).mockResolvedValueOnce({
+      message: 'hello new message',
+      messageId: 'mock-msg-id',
+      chatId: 'chat-router',
+      agentId: 'new-agent',
+      sessionId: 'new-session',
+      env: { ROUTER_VAR: 'router-val' },
+      reply: 'I routed this for you.',
+    });
+
+    const settings = {
+      defaultAgent: {
+        commands: { new: 'echo main' },
+      },
+    };
+
+    await handleUserMessage(
+      'chat-router',
+      'hello world',
+      settings as any,
+      '/dir-router',
+      false,
+      runCommandCallback
+    );
+
+    // Verify userMsg is saved with original message
+    expect(chats.appendMessage).toHaveBeenCalledWith(
+      'chat-router',
+      expect.objectContaining({
+        role: 'user',
+        content: 'hello world',
+      })
+    );
+
+    // Verify router reply is saved before agent runs
+    expect(chats.appendMessage).toHaveBeenCalledWith(
+      'chat-router',
+      expect.objectContaining({
+        role: 'log',
+        source: 'router',
+        content: 'I routed this for you.',
+      })
+    );
+
+    // Verify resolveSessionState is called with finalAgentId and finalSessionId
+    expect(workspace.readAgentSessionSettings).toHaveBeenCalledWith(
+      'new-agent',
+      'new-session',
+      '/dir-router'
+    );
+
+    // Verify execution used updated env
+    expect(mockSpawn).toHaveBeenCalledWith(
+      'echo main',
+      expect.objectContaining({
+        env: expect.objectContaining({
+          ROUTER_VAR: 'router-val',
+          CLAW_CLI_MESSAGE: 'hello new message',
+        }),
+      })
+    );
+  });
+});

package/src/daemon/message-session.test.ts

@@ -0,0 +1,127 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { handleUserMessage } from './message.js';
+import * as workspace from '../shared/workspace.js';
+import { spawn } from 'node:child_process';
+import { runCommandCallback, createAutoFinishMockSpawn } from './message-test-utils.js';
+
+vi.mock('node:child_process', () => ({ spawn: vi.fn() }));
+vi.mock('../shared/chats.js', () => ({ appendMessage: vi.fn().mockResolvedValue(undefined) }));
+vi.mock('./routers.js', () => ({
+  executeRouterPipeline: vi.fn().mockImplementation((state) => Promise.resolve(state)),
+}));
+vi.mock('../shared/workspace.js', () => ({
+  readChatSettings: vi.fn().mockResolvedValue(null),
+  writeChatSettings: vi.fn().mockResolvedValue(undefined),
+  readAgentSessionSettings: vi.fn().mockResolvedValue(null),
+  writeAgentSessionSettings: vi.fn().mockResolvedValue(undefined),
+  getAgent: vi.fn().mockResolvedValue(null),
+  getWorkspaceRoot: vi.fn().mockImplementation((cwd) => cwd),
+  getActiveEnvironmentName: vi.fn().mockResolvedValue(null),
+  getActiveEnvironmentInfo: vi.fn().mockResolvedValue(null),
+  getEnvironmentPath: vi.fn().mockReturnValue(''),
+  readEnvironment: vi.fn().mockResolvedValue(null),
+}));
+
+describe('Session Resolution & Execution', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('executes commands.new if session state file does not exist', async () => {
+    const mockSpawn = createAutoFinishMockSpawn();
+    (spawn as any).mockImplementation(mockSpawn);
+
+    vi.mocked(workspace.readChatSettings).mockResolvedValue(null);
+    vi.mocked(workspace.readAgentSessionSettings).mockResolvedValue(null);
+
+    const settings = { defaultAgent: { commands: { new: 'echo new', append: 'echo append' } } };
+
+    await handleUserMessage(
+      'chat1',
+      'hello',
+      settings as any,
+      '/dir-sess-1',
+      false,
+      runCommandCallback,
+      'my-session'
+    );
+
+    expect(workspace.readChatSettings).toHaveBeenCalledWith('chat1', '/dir-sess-1');
+    expect(workspace.readAgentSessionSettings).toHaveBeenCalledWith(
+      'default',
+      'my-session',
+      '/dir-sess-1'
+    );
+    expect(mockSpawn).toHaveBeenCalledWith(
+      'echo new',
+      expect.objectContaining({ cwd: '/dir-sess-1' })
+    );
+  });
+
+  it('executes commands.append if session state file exists and injects environment', async () => {
+    const mockSpawn = createAutoFinishMockSpawn();
+    (spawn as any).mockImplementation(mockSpawn);
+
+    vi.mocked(workspace.readChatSettings).mockResolvedValue({
+      defaultAgent: 'my-agent',
+      sessions: { 'my-agent': 'chat-session' },
+    });
+    vi.mocked(workspace.readAgentSessionSettings).mockResolvedValue({
+      env: { SESSION_ID: '12345' },
+    });
+
+    const settings = { defaultAgent: { commands: { new: 'echo new', append: 'echo append' } } };
+
+    await handleUserMessage(
+      'chat1',
+      'hello',
+      settings as any,
+      '/dir-sess-3',
+      false,
+      runCommandCallback
+    );
+
+    // Should use inferred session from chatSettings
+    expect(workspace.readAgentSessionSettings).toHaveBeenCalledWith(
+      'my-agent',
+      'chat-session',
+      '/dir-sess-3'
+    );
+
+    // Should have called spawn with `echo append`
+    expect(mockSpawn).toHaveBeenCalledWith(
+      'echo append',
+      expect.objectContaining({
+        env: expect.objectContaining({
+          SESSION_ID: '12345',
+          CLAW_CLI_MESSAGE: 'hello',
+        }),
+      })
+    );
+  });
+
+  it('falls back to commands.new if session exists but commands.append is undefined', async () => {
+    const mockSpawn = createAutoFinishMockSpawn();
+    (spawn as any).mockImplementation(mockSpawn);
+
+    vi.mocked(workspace.readChatSettings).mockResolvedValue(null);
+    vi.mocked(workspace.readAgentSessionSettings).mockResolvedValue({
+      env: { SESSION_ID: '12345' },
+    });
+
+    const settings = { defaultAgent: { commands: { new: 'echo new' } } };
+
+    await handleUserMessage(
+      'chat1',
+      'hello',
+      settings as any,
+      '/dir-sess-2',
+      false,
+      runCommandCallback,
+      'my-session'
+    );
+
+    expect(mockSpawn).toHaveBeenCalledWith('echo new', expect.anything());
+  });
+});

package/src/daemon/message-test-utils.ts

@@ -0,0 +1,41 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { vi } from 'vitest';
+import { EventEmitter } from 'node:events';
+
+export { runCommand as runCommandCallback } from './utils/spawn.js';
+
+export function createMockSpawn() {
+  const mockSpawn = vi.fn().mockImplementation((_cmd, _options) => {
+    const emitter = new EventEmitter() as any;
+    emitter.stdout = new EventEmitter();
+    emitter.stderr = new EventEmitter();
+    emitter.stdin = { write: vi.fn(), end: vi.fn(), on: vi.fn() };
+
+    emitter.finish = (code: number) => {
+      emitter.emit('close', code);
+    };
+
+    emitter.fail = (err: Error) => {
+      emitter.emit('error', err);
+    };
+
+    (mockSpawn as any).emitters = (mockSpawn as any).emitters || [];
+    (mockSpawn as any).emitters.push(emitter);
+    (mockSpawn as any).lastEmitter = emitter;
+    return emitter;
+  });
+  return mockSpawn;
+}
+
+export function createAutoFinishMockSpawn() {
+  const mockSpawn = vi.fn().mockImplementation(() => {
+    const emitter = new EventEmitter() as any;
+    emitter.stdout = new EventEmitter();
+    emitter.stderr = new EventEmitter();
+    emitter.stdin = { write: vi.fn(), end: vi.fn(), on: vi.fn() };
+    emitter.finish = (code: number) => emitter.emit('close', code);
+    setTimeout(() => emitter.finish(0), 0);
+    return emitter;
+  });
+  return mockSpawn;
+}

package/src/daemon/message-typing.test.ts

@@ -0,0 +1,93 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { executeDirectMessage } from './message.js';
+import * as events from './events.js';
+
+vi.mock('./events.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('./events.js')>();
+  return {
+    ...actual,
+    emitTyping: vi.fn(),
+    emitMessageAppended: vi.fn(),
+  };
+});
+
+vi.mock('../shared/chats.js', () => ({
+  appendMessage: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock('./queue.js', () => ({
+  getQueue: vi.fn().mockReturnValue({
+    enqueue: (fn: any) => fn(),
+  }),
+}));
+
+vi.mock('../shared/workspace.js', () => ({
+  readChatSettings: vi.fn().mockResolvedValue(null),
+  writeChatSettings: vi.fn().mockResolvedValue(undefined),
+  readAgentSessionSettings: vi.fn().mockResolvedValue(null),
+  writeAgentSessionSettings: vi.fn().mockResolvedValue(undefined),
+  getAgent: vi.fn().mockResolvedValue(null),
+  getWorkspaceRoot: vi.fn().mockImplementation((cwd) => cwd),
+  getActiveEnvironmentName: vi.fn().mockResolvedValue(null),
+  getActiveEnvironmentInfo: vi.fn().mockResolvedValue(null),
+  getEnvironmentPath: vi.fn().mockReturnValue(''),
+  readEnvironment: vi.fn().mockResolvedValue(null),
+}));
+
+describe('executeDirectMessage - Typing Indicator', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('should emit typing events at an interval and clear them upon completion', async () => {
+    const chatId = 'test-typing-chat';
+    const state = {
+      message: 'hello typing',
+      chatId,
+      messageId: 'mock-id',
+    };
+    const settings = {
+      defaultAgent: {
+        commands: { new: 'echo start' },
+      },
+    } as any;
+
+    // We mock runCommand to delay its completion so we can advance timers
+    const mockRunCommand = vi.fn().mockImplementation(() => {
+      return new Promise((resolve) => {
+        // We simulate that command takes 12000ms
+        setTimeout(() => {
+          resolve({ stdout: 'done', stderr: '', exitCode: 0 });
+        }, 12000);
+      });
+    });
+
+    const execPromise = executeDirectMessage(chatId, state, settings, '/dir', mockRunCommand, true);
+
+    // Advance time by 5000ms. Interval is set to 5000ms.
+    await vi.advanceTimersByTimeAsync(5000);
+    expect(events.emitTyping).toHaveBeenCalledTimes(1);
+    expect(events.emitTyping).toHaveBeenCalledWith(chatId);
+
+    // Advance time by another 5000ms (10000ms total)
+    await vi.advanceTimersByTimeAsync(5000);
+    expect(events.emitTyping).toHaveBeenCalledTimes(2);
+
+    // Advance time past the command finish (12000ms total)
+    await vi.advanceTimersByTimeAsync(2000);
+    await execPromise;
+
+    // Now the command is finished, interval should be cleared
+    // Advance by another 10000ms, it shouldn't trigger again
+    await vi.advanceTimersByTimeAsync(10000);
+
+    // Total should still be 2, because the interval was cleared.
+    expect(events.emitTyping).toHaveBeenCalledTimes(2);
+  });
+});

package/src/daemon/message-verbosity.test.ts

@@ -0,0 +1,127 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { handleUserMessage } from './message.js';
+import * as chats from '../shared/chats.js';
+
+vi.mock('../shared/chats.js', () => ({
+  appendMessage: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock('./routers.js', () => ({
+  executeRouterPipeline: vi.fn().mockImplementation((state) =>
+    Promise.resolve({
+      ...state,
+      reply: state.message.includes('NO_REPLY_NECESSARY') ? 'NO_REPLY_NECESSARY' : undefined,
+    })
+  ),
+}));
+vi.mock('../shared/workspace.js', () => ({
+  readChatSettings: vi.fn().mockResolvedValue(null),
+  writeChatSettings: vi.fn().mockResolvedValue(undefined),
+  readAgentSessionSettings: vi.fn().mockResolvedValue(null),
+  writeAgentSessionSettings: vi.fn().mockResolvedValue(undefined),
+  getAgent: vi.fn().mockResolvedValue(null),
+  getWorkspaceRoot: vi.fn().mockImplementation((cwd) => cwd),
+  getActiveEnvironmentName: vi.fn().mockResolvedValue(null),
+  getActiveEnvironmentInfo: vi.fn().mockResolvedValue(null),
+  getEnvironmentPath: vi.fn().mockReturnValue(''),
+  readEnvironment: vi.fn().mockResolvedValue(null),
+}));
+
+describe('Message Verbosity (NO_REPLY_NECESSARY)', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('sets level to verbose for logMsg if stdout includes NO_REPLY_NECESSARY', async () => {
+    const runCommandMock = vi.fn().mockResolvedValue({
+      stdout: 'Some output with NO_REPLY_NECESSARY inside',
+      stderr: '',
+      exitCode: 0,
+    });
+
+    const settings = {
+      defaultAgent: {
+        commands: { new: 'echo test' },
+      },
+    };
+
+    await handleUserMessage(
+      'chat-verbose-1',
+      'hello',
+      settings as any,
+      '/dir',
+      false,
+      runCommandMock
+    );
+
+    expect(chats.appendMessage).toHaveBeenCalled();
+    const calls = vi.mocked(chats.appendMessage).mock.calls;
+    // The last appendMessage should be the logMsg
+    const logMsgCall = calls.find(
+      (call) => (call[1] as any).role === 'log' && (call[1] as any).command === 'echo test'
+    );
+    expect(logMsgCall).toBeDefined();
+    expect((logMsgCall![1] as any).level).toBe('verbose');
+  });
+
+  it('does not set level to verbose for logMsg if stdout does not include NO_REPLY_NECESSARY', async () => {
+    const runCommandMock = vi.fn().mockResolvedValue({
+      stdout: 'Normal output',
+      stderr: '',
+      exitCode: 0,
+    });
+
+    const settings = {
+      defaultAgent: {
+        commands: { new: 'echo test' },
+      },
+    };
+
+    await handleUserMessage(
+      'chat-verbose-2',
+      'hello',
+      settings as any,
+      '/dir',
+      false,
+      runCommandMock
+    );
+
+    const calls = vi.mocked(chats.appendMessage).mock.calls;
+    const logMsgCall = calls.find(
+      (call) => (call[1] as any).role === 'log' && (call[1] as any).command === 'echo test'
+    );
+    expect(logMsgCall).toBeDefined();
+    expect((logMsgCall![1] as any).level).toBeUndefined();
+  });
+
+  it('sets level to verbose for routerLogMsg if state.reply includes NO_REPLY_NECESSARY', async () => {
+    const runCommandMock = vi.fn().mockResolvedValue({
+      stdout: 'Normal output',
+      stderr: '',
+      exitCode: 0,
+    });
+
+    const settings = {
+      defaultAgent: {
+        commands: { new: 'echo test' },
+      },
+    };
+
+    // message includes NO_REPLY_NECESSARY to trigger our mocked router setting it as reply
+    await handleUserMessage(
+      'chat-verbose-3',
+      'trigger NO_REPLY_NECESSARY via mock router',
+      settings as any,
+      '/dir',
+      false,
+      runCommandMock
+    );
+
+    const calls = vi.mocked(chats.appendMessage).mock.calls;
+    const routerLogMsgCall = calls.find(
+      (call) => (call[1] as any).role === 'log' && (call[1] as any).source === 'router'
+    );
+    expect(routerLogMsgCall).toBeDefined();
+    expect((routerLogMsgCall![1] as any).level).toBe('verbose');
+  });
+});