clawmini 0.0.1

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

@@ -0,0 +1,166 @@
+/* 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 { spawn } from 'node:child_process';
+import { runCommandCallback } from './message-test-utils.js';
+import { EventEmitter } from 'node:events';
+
+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('Extraction Logic', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('spawns getSessionId on a new session, parses output, and updates state files', async () => {
+    const mockSpawn = vi.fn().mockImplementation((cmd) => {
+      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(() => {
+        if (cmd === 'echo main') {
+          emitter.stdout.emit('data', 'main_output');
+          emitter.finish(0);
+        } else if (cmd === 'echo getSessionId') {
+          emitter.stdout.emit('data', 'new-session-id-123\n');
+          emitter.finish(0);
+        } else {
+          emitter.finish(0);
+        }
+      }, 0);
+
+      return emitter;
+    });
+    (spawn as any).mockImplementation(mockSpawn);
+
+    vi.mocked(workspace.readChatSettings).mockResolvedValue({ defaultAgent: 'my-agent' });
+    vi.mocked(workspace.readAgentSessionSettings).mockResolvedValue(null); // new session
+
+    const settings = {
+      defaultAgent: {
+        commands: {
+          new: 'echo main',
+          getSessionId: 'echo getSessionId',
+        },
+      },
+    };
+
+    await handleUserMessage(
+      'chat1',
+      'hello',
+      settings as any,
+      '/dir-extract-1',
+      false,
+      runCommandCallback
+    );
+
+    // Verify spawn was called twice
+    expect(mockSpawn).toHaveBeenCalledTimes(2);
+    expect(mockSpawn).toHaveBeenNthCalledWith(1, 'echo main', expect.anything());
+    // The second call is getSessionId, and its stdin should have been piped in the callback
+    expect(mockSpawn).toHaveBeenNthCalledWith(2, 'echo getSessionId', expect.anything());
+
+    // Verify state files were updated
+    expect(workspace.writeChatSettings).toHaveBeenCalledWith(
+      'chat1',
+      expect.objectContaining({
+        defaultAgent: 'my-agent',
+        sessions: { 'my-agent': 'default' },
+      }),
+      '/dir-extract-1'
+    );
+
+    expect(workspace.writeAgentSessionSettings).toHaveBeenCalledWith(
+      'my-agent',
+      'default',
+      { env: { SESSION_ID: 'new-session-id-123' } },
+      '/dir-extract-1'
+    );
+  });
+
+  it('spawns getMessageContent, piping main stdout', async () => {
+    const mockSpawn = vi.fn().mockImplementation((cmd) => {
+      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(() => {
+        if (cmd === 'echo main') {
+          emitter.stdout.emit('data', 'main_output');
+          emitter.finish(0);
+        } else if (cmd === 'echo getMessageContent') {
+          emitter.stdout.emit('data', 'extracted message content');
+          emitter.finish(0);
+        } else {
+          emitter.finish(0);
+        }
+      }, 0);
+
+      return emitter;
+    });
+    (spawn as any).mockImplementation(mockSpawn);
+
+    vi.mocked(workspace.readChatSettings).mockResolvedValue(null);
+    // Not a new session
+    vi.mocked(workspace.readAgentSessionSettings).mockResolvedValue({ env: {} });
+
+    const settings = {
+      defaultAgent: {
+        commands: {
+          new: 'echo main',
+          append: 'echo main',
+          getMessageContent: 'echo getMessageContent',
+        },
+      },
+    };
+
+    await handleUserMessage(
+      'chat1',
+      'hello',
+      settings as any,
+      '/dir-extract-2',
+      false,
+      runCommandCallback
+    );
+
+    expect(mockSpawn).toHaveBeenCalledTimes(2);
+    expect(mockSpawn).toHaveBeenNthCalledWith(2, 'echo getMessageContent', expect.anything());
+
+    // Extraction success doesn't update state files (except log, which is tested via Chats mock)
+    expect(chats.appendMessage).toHaveBeenCalledWith(
+      'chat1',
+      expect.objectContaining({
+        role: 'log',
+        content: 'extracted message content',
+        stdout: 'main_output',
+      })
+    );
+  });
+});

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

@@ -0,0 +1,313 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { handleUserMessage, calculateDelay } from './message.js';
+import { spawn } from 'node:child_process';
+import { runCommandCallback } from './message-test-utils.js';
+import * as chats from '../shared/chats.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('calculateDelay', () => {
+  const baseDelay = 1000;
+
+  it('returns 0 for attempt 0', () => {
+    expect(calculateDelay(0, baseDelay)).toBe(0);
+  });
+
+  it('returns baseDelay for attempt 0 on fallback', () => {
+    expect(calculateDelay(0, baseDelay, true)).toBe(baseDelay);
+  });
+
+  it('returns baseDelay for attempt 1', () => {
+    expect(calculateDelay(1, baseDelay)).toBe(baseDelay);
+  });
+
+  it('doubles delay for attempt 2', () => {
+    expect(calculateDelay(2, baseDelay)).toBe(2000);
+  });
+
+  it('doubles delay for attempt 3', () => {
+    expect(calculateDelay(3, baseDelay)).toBe(4000);
+  });
+
+  it('doubles delay for attempt 4', () => {
+    expect(calculateDelay(4, baseDelay)).toBe(8000);
+  });
+
+  it('caps delay at 15000ms', () => {
+    expect(calculateDelay(5, baseDelay)).toBe(15000);
+    expect(calculateDelay(10, baseDelay)).toBe(15000);
+  });
+
+  it('respects a different baseDelay', () => {
+    const customBase = 500;
+    expect(calculateDelay(1, customBase)).toBe(500);
+    expect(calculateDelay(2, customBase)).toBe(1000);
+    expect(calculateDelay(6, customBase)).toBe(15000); // 500 * 2^5 = 16000, capped at 15000
+  });
+});
+
+describe('Message Fallbacks & Retries', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('retries when base attempt fails (exit code 1) and succeeds on fallback', async () => {
+    let callCount = 0;
+    const mockSpawn = vi.fn().mockImplementation((_cmd, _options) => {
+      callCount++;
+      const emitter: any = {
+        on: vi.fn((event, cb) => {
+          if (event === 'close') {
+            // First call fails, second call succeeds
+            cb(callCount === 1 ? 1 : 0);
+          }
+          return emitter;
+        }),
+        stdout: {
+          on: vi.fn((event, cb) => {
+            if (event === 'data') cb(Buffer.from(`output ${callCount}`));
+            return emitter;
+          }),
+        },
+        stderr: {
+          on: vi.fn((event, cb) => {
+            if (event === 'data' && callCount === 1) cb(Buffer.from('error'));
+            return emitter;
+          }),
+        },
+      };
+      return emitter;
+    });
+    (spawn as any).mockImplementation(mockSpawn);
+
+    const settings = {
+      defaultAgent: {
+        commands: { new: 'echo base' },
+        fallbacks: [
+          {
+            commands: { new: 'echo fallback' },
+            retries: 0,
+          },
+        ],
+      },
+    };
+
+    await handleUserMessage(
+      'chat-fallback',
+      'hello',
+      settings as any,
+      '/dir',
+      false,
+      runCommandCallback
+    );
+
+    // Should call base once, then fallback once
+    expect(mockSpawn).toHaveBeenCalledTimes(2);
+    expect(mockSpawn).toHaveBeenNthCalledWith(1, 'echo base', expect.anything());
+    expect(mockSpawn).toHaveBeenNthCalledWith(2, 'echo fallback', expect.anything());
+
+    // Should append the successful log message
+    expect(chats.appendMessage).toHaveBeenCalledWith(
+      'chat-fallback',
+      expect.objectContaining({
+        role: 'log',
+        content: 'output 2',
+        exitCode: 0,
+      }),
+      expect.any(String)
+    );
+  });
+
+  it('retries when getMessageContent returns empty string', async () => {
+    let callCount = 0;
+    const mockSpawn = vi.fn().mockImplementation((cmd, _options) => {
+      callCount++;
+      // cmd can be 'echo base', 'extract', or 'echo fallback'
+      // We want to return empty string for 'extract' when it's called after 'echo base'
+      let output = `output ${callCount}`;
+      if (cmd === 'extract' && callCount === 2) {
+        output = '';
+      }
+
+      const emitter: any = {
+        on: vi.fn((event, cb) => {
+          if (event === 'close') cb(0);
+          return emitter;
+        }),
+        stdout: {
+          on: vi.fn((event, cb) => {
+            if (event === 'data') cb(Buffer.from(output));
+            return emitter;
+          }),
+        },
+        stderr: { on: vi.fn() },
+      };
+      return emitter;
+    });
+    (spawn as any).mockImplementation(mockSpawn);
+
+    const settings = {
+      defaultAgent: {
+        commands: { new: 'echo base', getMessageContent: 'extract' },
+        fallbacks: [
+          {
+            commands: { new: 'echo fallback' },
+            retries: 0,
+          },
+        ],
+      },
+    };
+
+    await handleUserMessage(
+      'chat-empty',
+      'hello',
+      settings as any,
+      '/dir',
+      false,
+      runCommandCallback
+    );
+
+    // Call 1: base (success)
+    // Call 2: getMessageContent (returns empty -> failure)
+    // Call 3: fallback (success)
+    // Call 4: getMessageContent for fallback (success)
+    expect(mockSpawn).toHaveBeenCalledTimes(4);
+    expect(mockSpawn).toHaveBeenNthCalledWith(1, 'echo base', expect.anything());
+    expect(mockSpawn).toHaveBeenNthCalledWith(2, 'extract', expect.anything());
+    expect(mockSpawn).toHaveBeenNthCalledWith(3, 'echo fallback', expect.anything());
+    expect(mockSpawn).toHaveBeenNthCalledWith(4, 'extract', expect.anything());
+  });
+
+  it('supports multiple retries for a single fallback', async () => {
+    let callCount = 0;
+    const mockSpawn = vi.fn().mockImplementation((_cmd, _options) => {
+      callCount++;
+      const emitter: any = {
+        on: vi.fn((event, cb) => {
+          if (event === 'close') {
+            // Call 1 (base) fails
+            // Call 2 (fallback attempt 0) fails
+            // Call 3 (fallback attempt 1) succeeds
+            cb(callCount < 3 ? 1 : 0);
+          }
+          return emitter;
+        }),
+        stdout: {
+          on: vi.fn((event, cb) => {
+            if (event === 'data') cb(Buffer.from(`output ${callCount}`));
+            return emitter;
+          }),
+        },
+        stderr: { on: vi.fn() },
+      };
+      return emitter;
+    });
+    (spawn as any).mockImplementation(mockSpawn);
+
+    const settings = {
+      defaultAgent: {
+        commands: { new: 'echo base' },
+        fallbacks: [
+          {
+            commands: { new: 'echo fallback' },
+            retries: 2,
+          },
+        ],
+      },
+    };
+
+    await handleUserMessage(
+      'chat-retries',
+      'hello',
+      settings as any,
+      '/dir',
+      false,
+      runCommandCallback
+    );
+
+    // Call 1: base (fail)
+    // Call 2: fallback attempt 0 (fail)
+    // Call 3: fallback attempt 1 (success)
+    expect(mockSpawn).toHaveBeenCalledTimes(3);
+    expect(mockSpawn).toHaveBeenNthCalledWith(1, 'echo base', expect.anything());
+    expect(mockSpawn).toHaveBeenNthCalledWith(2, 'echo fallback', expect.anything());
+    expect(mockSpawn).toHaveBeenNthCalledWith(3, 'echo fallback', expect.anything());
+  });
+
+  it('appends a log message before waiting for retry delay', async () => {
+    let callCount = 0;
+    const mockSpawn = vi.fn().mockImplementation((_cmd, _options) => {
+      callCount++;
+      const emitter: any = {
+        on: vi.fn((event, cb) => {
+          if (event === 'close') {
+            // Call 1 (base) fails
+            // Call 2 (fallback attempt 0) fails
+            // Call 3 (fallback attempt 1) succeeds
+            cb(callCount < 3 ? 1 : 0);
+          }
+          return emitter;
+        }),
+        stdout: {
+          on: vi.fn((event, cb) => {
+            if (event === 'data') cb(Buffer.from('output'));
+            return emitter;
+          }),
+        },
+        stderr: { on: vi.fn() },
+      };
+      return emitter;
+    });
+    (spawn as any).mockImplementation(mockSpawn);
+
+    const settings = {
+      defaultAgent: {
+        commands: { new: 'echo base' },
+        fallbacks: [
+          {
+            commands: { new: 'echo fallback' },
+            retries: 1,
+            delayMs: 1000,
+          },
+        ],
+      },
+    };
+
+    await handleUserMessage(
+      'chat-log-retry',
+      'hello',
+      settings as any,
+      '/dir',
+      false,
+      runCommandCallback
+    );
+
+    // Should find the retry log message
+    expect(chats.appendMessage).toHaveBeenCalledWith(
+      'chat-log-retry',
+      expect.objectContaining({
+        role: 'log',
+        content: 'Error running agent, retrying in 1 seconds...',
+        command: 'retry-delay',
+      }),
+      expect.any(String)
+    );
+  });
+});

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

@@ -0,0 +1,125 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { executeDirectMessage } from './message.js';
+import { getQueue } from './queue.js';
+import type { RouterState } from './routers/types.js';
+
+vi.mock('./chats.js', () => ({
+  appendMessage: vi.fn().mockResolvedValue(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('Interruption flow in message handler', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('stops execution and clears queue when action is stop', async () => {
+    const queue = getQueue('/test-interrupt-stop');
+    const abortSpy = vi.spyOn(queue, 'abortCurrent');
+    const clearSpy = vi.spyOn(queue, 'clear');
+
+    const state: RouterState = {
+      message: 'stop everything',
+      messageId: 'mock-msg-id',
+      chatId: 'chat1',
+      action: 'stop',
+    };
+
+    const runCommand = vi.fn();
+    await executeDirectMessage('chat1', state, undefined, '/test-interrupt-stop', runCommand, true);
+
+    expect(abortSpy).toHaveBeenCalled();
+    expect(clearSpy).toHaveBeenCalled();
+    expect(runCommand).not.toHaveBeenCalled();
+
+    // We expect it NOT to enqueue because it returns early
+    expect(queue['pending'].length).toBe(0);
+  });
+
+  it('interrupts execution and batches pending tasks when action is interrupt', async () => {
+    const queue = getQueue('/test-interrupt-batch');
+    const abortSpy = vi.spyOn(queue, 'abortCurrent');
+
+    // Block the queue with a running task so subsequent ones stay pending
+    queue
+      .enqueue(async () => {
+        await new Promise((r) => setTimeout(r, 500));
+      })
+      .catch(() => {});
+
+    // Enqueue some dummy tasks with payloads
+    queue
+      .enqueue(async () => {
+        await new Promise((r) => setTimeout(r, 100));
+      }, 'pending 1')
+      .catch(() => {});
+    queue
+      .enqueue(async () => {
+        await new Promise((r) => setTimeout(r, 100));
+      }, 'pending 2')
+      .catch(() => {});
+
+    const state: RouterState = {
+      message: 'new urgent task',
+      messageId: 'mock-msg-id',
+      chatId: 'chat1',
+      action: 'interrupt',
+    };
+
+    const runCommand = vi.fn().mockResolvedValue({ stdout: 'done', stderr: '', exitCode: 0 });
+
+    await executeDirectMessage(
+      'chat1',
+      state,
+      undefined,
+      '/test-interrupt-batch',
+      runCommand,
+      true
+    );
+
+    expect(abortSpy).toHaveBeenCalled();
+
+    // Should have concatenated the pending tasks with the new message
+    // and enqueued it.
+
+    // In our executeDirectMessage, the state.message gets mutated.
+    // However, it's easier to verify what was enqueued by extracting pending again,
+    // or by checking state.message.
+    expect(state.message).toBe(
+      '<message>\npending 1\n</message>\n\n<message>\npending 2\n</message>\n\n<message>\nnew urgent task\n</message>'
+    );
+  });
+
+  it('returns early when message is empty and no action is specified', async () => {
+    const queue = getQueue('/test-interrupt-empty');
+    const state: RouterState = {
+      message: '   ',
+      messageId: 'mock-msg-id',
+      chatId: 'chat1',
+    };
+
+    const runCommand = vi.fn();
+    await executeDirectMessage(
+      'chat1',
+      state,
+      undefined,
+      '/test-interrupt-empty',
+      runCommand,
+      true
+    );
+
+    expect(runCommand).not.toHaveBeenCalled();
+    expect(queue['pending'].length).toBe(0);
+  });
+});